254 lines
9.6 KiB
Python
254 lines
9.6 KiB
Python
# Copyright 2026 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""UI Launch and Web Console CLI Command (artemis ui)."""
|
|
|
|
from pathlib import Path
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import time
|
|
from typing import Annotated
|
|
import urllib.request
|
|
import webbrowser
|
|
|
|
from rich.console import Console
|
|
from rich.panel import Panel
|
|
import typer
|
|
|
|
|
|
def running_via_console_script_shim() -> bool:
|
|
"""Return True when this CLI was launched through a console-script ``.exe`` shim.
|
|
|
|
On Windows, ``uv``/pip install entry points as trampoline executables
|
|
(``Scripts/artemis.exe``) that stay resident for the lifetime of the CLI
|
|
process and hold a lock on their own file. A long-running foreground server
|
|
started through the shim therefore blocks ``uv sync`` from reinstalling the
|
|
package ("os error 32") until the server exits. Launching via
|
|
``python -m artemis`` avoids the shim entirely.
|
|
"""
|
|
if sys.platform != "win32":
|
|
return False
|
|
argv0 = Path(sys.argv[0] or "")
|
|
return argv0.suffix.lower() == ".exe" and argv0.name.lower() != "python.exe"
|
|
|
|
|
|
def warn_if_console_script_shim(console: Console) -> None:
|
|
"""Print a hint when a foreground server run will pin the console-script exe."""
|
|
if running_via_console_script_shim():
|
|
console.print(
|
|
" [dim]β Running in foreground via the [bold]artemis.exe[/bold] launcher: package "
|
|
"syncs (uv sync / uv run) cannot replace it while this server is running.\n"
|
|
" Prefer [bold]artemis restart[/bold] (background daemon) or launch with "
|
|
"[bold]uv run python -m artemis ui[/bold] to avoid this.[/dim]\n"
|
|
)
|
|
|
|
|
|
def _resolve_npm_executable(platform_name: str | None = None) -> str | None:
|
|
"""Return a directly executable npm path for the current platform."""
|
|
platform_name = platform_name or sys.platform
|
|
candidates = ("npm.cmd", "npm.exe", "npm") if platform_name == "win32" else ("npm",)
|
|
return next((path for candidate in candidates if (path := shutil.which(candidate))), None)
|
|
|
|
|
|
def _showcase_build_required(showcase_dir: Path) -> bool:
|
|
"""Return whether the compiled Angular app is missing or older than its inputs."""
|
|
base_dist = showcase_dir / "dist"
|
|
candidates = [
|
|
base_dist / "frontend" / "browser" / "index.html",
|
|
base_dist / "browser" / "index.html",
|
|
base_dist / "frontend" / "index.html",
|
|
base_dist / "index.html",
|
|
]
|
|
built_indexes = [path for path in candidates if path.exists()]
|
|
if not built_indexes:
|
|
return True
|
|
|
|
build_time = max(path.stat().st_mtime for path in built_indexes)
|
|
input_paths = [showcase_dir / "package.json", showcase_dir / "angular.json"]
|
|
source_dir = showcase_dir / "src"
|
|
if source_dir.exists():
|
|
input_paths.extend(path for path in source_dir.rglob("*") if path.is_file())
|
|
return any(path.exists() and path.stat().st_mtime > build_time for path in input_paths)
|
|
|
|
|
|
def ensure_showcase_built(console: Console) -> None:
|
|
"""Rebuild the Angular Showcase UI when its sources are newer than the dist build."""
|
|
from artemis.config.paths import ROOT_DIR
|
|
|
|
showcase_dir = ROOT_DIR / "apps" / "showcase_ui"
|
|
if not _showcase_build_required(showcase_dir):
|
|
return
|
|
npm_executable = _resolve_npm_executable()
|
|
if not npm_executable:
|
|
return
|
|
console.print(" [yellow]π¨ Showcase UI sources changed. Compiling Angular Showcase UI...[/yellow]")
|
|
try:
|
|
subprocess.run([npm_executable, "install", "--silent"], cwd=showcase_dir, check=True)
|
|
subprocess.run([npm_executable, "run", "build"], cwd=showcase_dir, check=True)
|
|
console.print(" [green]β Showcase UI built successfully.[/green]\n")
|
|
except Exception as e:
|
|
console.print(f" [red]β Failed to auto-build Showcase UI: {e}[/red]\n")
|
|
|
|
|
|
def _poll_and_open_browser(url: str, stop_event: threading.Event, timeout: float = 15.0) -> None:
|
|
"""Poll the UI server until it responds, then launch the user's default browser."""
|
|
start = time.time()
|
|
while not stop_event.is_set() and (time.time() - start < timeout):
|
|
try:
|
|
req = urllib.request.Request(url, headers={"User-Agent": "Artemis-HealthCheck/1.0"})
|
|
with urllib.request.urlopen(req, timeout=1.5) as resp:
|
|
if resp.status == 200:
|
|
time.sleep(0.3)
|
|
webbrowser.open(url)
|
|
return
|
|
except Exception:
|
|
time.sleep(0.4)
|
|
|
|
|
|
def ui_command(
|
|
host: Annotated[
|
|
str,
|
|
typer.Option(
|
|
"--host",
|
|
"-h",
|
|
help=(
|
|
"Bind host address for the UI server. Defaults to loopback; for remote "
|
|
"access prefer a Tailscale/SSH tunnel over a wide bind."
|
|
),
|
|
),
|
|
] = "127.0.0.1",
|
|
port: Annotated[
|
|
int,
|
|
typer.Option("--port", "-p", help="Port to run the unified UI server on."),
|
|
] = 8000,
|
|
open_browser: Annotated[
|
|
bool,
|
|
typer.Option(
|
|
"--open/--no-open",
|
|
help="Automatically open the Showcase UI in default web browser.",
|
|
),
|
|
] = True,
|
|
reload: Annotated[
|
|
bool,
|
|
typer.Option(
|
|
"--reload/--no-reload",
|
|
help="Enable uvicorn live auto-reload (for development).",
|
|
),
|
|
] = False,
|
|
restart: Annotated[
|
|
bool,
|
|
typer.Option(
|
|
"--restart",
|
|
"-r",
|
|
help="Restart server by terminating any existing instance on the port first.",
|
|
),
|
|
] = False,
|
|
) -> None:
|
|
"""Launch the unified Artemis Showcase UI & Admin Console in one click."""
|
|
console = Console()
|
|
local_url = f"http://localhost:{port}"
|
|
|
|
from artemis.runtime.server_lifecycle import (
|
|
find_server_pids,
|
|
is_port_in_use,
|
|
stop_server,
|
|
)
|
|
|
|
if restart:
|
|
console.print(f" [yellow]π Restart requested. Recycling port {port}...[/yellow]")
|
|
stop_server(port=port, timeout=12.0)
|
|
elif is_port_in_use(port):
|
|
pids = find_server_pids(port)
|
|
pid_str = f" (PID: {', '.join(map(str, pids))})" if pids else ""
|
|
if sys.stdin.isatty():
|
|
console.print(f"\n [yellow]β Port {port} is already in use by an active Artemis server{pid_str}.[/yellow]")
|
|
console.print(" [dim]Choose an action:[/dim]")
|
|
console.print(" [bold]1[/bold] Open browser (default)")
|
|
console.print(" [bold]2[/bold] Restart server (stop existing and start here)")
|
|
console.print(" [bold]3[/bold] Cancel")
|
|
try:
|
|
choice = input(" Select [1-3, default 1]: ").strip()
|
|
except (KeyboardInterrupt, EOFError):
|
|
choice = "1"
|
|
if choice == "2":
|
|
console.print(f"\n [yellow]π Terminating previous Artemis instance on port {port}...[/yellow]")
|
|
stop_server(port=port, timeout=12.0)
|
|
elif choice == "3":
|
|
return
|
|
else:
|
|
if open_browser:
|
|
webbrowser.open(local_url)
|
|
return
|
|
else:
|
|
console.print(
|
|
f"\n [yellow]β Port {port} is already in use by Artemis{pid_str}. "
|
|
f"Use '[bold]artemis restart[/bold]' to restart.[/yellow]\n"
|
|
)
|
|
if open_browser:
|
|
webbrowser.open(local_url)
|
|
return
|
|
|
|
console.print()
|
|
msg = (
|
|
f"[bold cyan]β¨ Artemis Autonomous Mobile Agent UI[/bold cyan]\n\n"
|
|
f"π± [bold green]Showcase UI & Onboarding:[/bold green] [cyan]{local_url}[/cyan]\n"
|
|
f"π οΈ [bold magenta]Admin Debug Console:[/bold magenta] [cyan]{local_url}/admin[/cyan]\n"
|
|
f"π [dim]API Documentation:[/dim] [dim]{local_url}/docs[/dim]\n\n"
|
|
+ (
|
|
"[dim]Press Ctrl+C to stop while idle; Ctrl+Break forces shutdown during a task.[/dim]"
|
|
if sys.platform == "win32"
|
|
else "[dim]Press Ctrl+C to stop the server.[/dim]"
|
|
)
|
|
)
|
|
console.print(Panel(msg, title="π Web Server Active", border_style="cyan", expand=False))
|
|
# Ensure .env exists in workspace root
|
|
from artemis.config.paths import ROOT_DIR
|
|
|
|
env_file = ROOT_DIR / ".env"
|
|
env_example = ROOT_DIR / ".env.example"
|
|
if not env_file.exists():
|
|
if env_example.exists():
|
|
try:
|
|
env_file.write_text(env_example.read_text(encoding="utf-8"), encoding="utf-8")
|
|
except Exception:
|
|
pass
|
|
else:
|
|
try:
|
|
env_file.touch()
|
|
except Exception:
|
|
pass
|
|
|
|
ensure_showcase_built(console)
|
|
warn_if_console_script_shim(console)
|
|
|
|
stop_event = threading.Event()
|
|
if open_browser:
|
|
t = threading.Thread(
|
|
target=_poll_and_open_browser,
|
|
args=(local_url, stop_event),
|
|
daemon=True,
|
|
)
|
|
t.start()
|
|
|
|
try:
|
|
from apps.admin_console.server import run_ui_server
|
|
|
|
run_ui_server(host=host, port=port, reload=reload)
|
|
except KeyboardInterrupt:
|
|
console.print("\n[yellow]π UI Server stopped.[/yellow]")
|
|
finally:
|
|
stop_event.set()
|