daemon_cmd

daemon_cmd

jarvis start|stop|restart|status — daemon management commands.

Functions

record_server_state

record_server_state(pid: int, host: str, port: int) -> None

Register a running server so jarvis status can find it.

Called by jarvis serve itself, so a server supervised by launchd/systemd (which never goes through jarvis start) is still reported as running.

Source code in src/openjarvis/cli/daemon_cmd.py

def record_server_state(pid: int, host: str, port: int) -> None:
    """Register a running server so `jarvis status` can find it.

    Called by `jarvis serve` itself, so a server supervised by launchd/systemd
    (which never goes through `jarvis start`) is still reported as running.
    """
    _write_pid(pid, host, port, launch_token=os.environ.get(_LAUNCH_TOKEN_ENV))

clear_server_state

clear_server_state(pid: int) -> None

Deregister a server on shutdown, but only if it still owns the files.

Source code in src/openjarvis/cli/daemon_cmd.py

def clear_server_state(pid: int) -> None:
    """Deregister a server on shutdown, but only if it still owns the files."""
    with _state_lock():
        _clear_state_unlocked(pid)

daemon

daemon() -> None

Manage the OpenJarvis server daemon.

Source code in src/openjarvis/cli/daemon_cmd.py

@click.group()
def daemon() -> None:
    """Manage the OpenJarvis server daemon."""

start

start(host: str | None, port: int | None, engine_key: str | None, model_name: str | None, agent_name: str | None) -> None

Start the OpenJarvis server as a background daemon.

Source code in src/openjarvis/cli/daemon_cmd.py

@daemon.command()
@click.option("--host", default=None, help="Bind address.")
@click.option("--port", default=None, type=int, help="Port number.")
@click.option("-e", "--engine", "engine_key", default=None, help="Engine backend.")
@click.option("-m", "--model", "model_name", default=None, help="Default model.")
@click.option("-a", "--agent", "agent_name", default=None, help="Agent type.")
def start(
    host: str | None,
    port: int | None,
    engine_key: str | None,
    model_name: str | None,
    agent_name: str | None,
) -> None:
    """Start the OpenJarvis server as a background daemon."""
    console = Console(stderr=True)

    existing = _read_pid()
    if existing is not None:
        console.print(f"[yellow]Server already running (PID {existing}).[/yellow]")
        console.print("Use 'jarvis stop' to stop it first, or 'jarvis restart'.")
        sys.exit(1)

    config = load_config()
    bind_host = host or config.server.host
    bind_port = port if port is not None else config.server.port

    # Build command to run jarvis serve
    cmd = [sys.executable, "-m", "openjarvis.cli", "serve"]
    if host:
        cmd.extend(["--host", host])
    if port is not None:
        cmd.extend(["--port", str(port)])
    if engine_key:
        cmd.extend(["--engine", engine_key])
    if model_name:
        cmd.extend(["--model", model_name])
    if agent_name:
        cmd.extend(["--agent", agent_name])

    # Start as background process, fully detached from the launching terminal.
    #
    # ``start_new_session`` is POSIX-only: CPython's Windows ``_execute_child``
    # names the parameter ``unused_start_new_session`` and ignores it. Relying
    # on it there leaves the server sharing its parent's console, so closing
    # that console — or logging off — delivers CTRL_CLOSE_EVENT and kills the
    # daemon. DETACHED_PROCESS gives it no console at all; the new process
    # group additionally stops a Ctrl-C in the parent reaching it.
    DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
    spawn_kwargs: dict = {}
    if sys.platform == "win32":
        spawn_kwargs["creationflags"] = (
            subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
        )
    else:
        spawn_kwargs["start_new_session"] = True
    launch_token = secrets.token_hex(16)
    proc = None
    registration_error = None
    # Serialize the final check, spawn, and pending registration. The server
    # waits on this same lock if it binds before its launcher finishes writing.
    with _state_lock():
        existing = _read_pid_unlocked()
        if existing is None:
            with open(_LOG_FILE, "a") as log_fh:
                proc = subprocess.Popen(
                    cmd,
                    stdout=log_fh,
                    stderr=log_fh,
                    env={**os.environ, _LAUNCH_TOKEN_ENV: launch_token},
                    **spawn_kwargs,
                )
            try:
                _write_pid_unlocked(
                    proc.pid,
                    bind_host,
                    bind_port,
                    ready=False,
                    launch_token=launch_token,
                )
            except (OSError, RuntimeError) as exc:
                registration_error = exc

    if existing is not None:
        console.print(f"[yellow]Server already running (PID {existing}).[/yellow]")
        console.print("Use 'jarvis stop' to stop it first, or 'jarvis restart'.")
        sys.exit(1)
    assert proc is not None
    if registration_error is not None:
        terminate_process(proc.pid, grace_seconds=10.0)
        clear_server_state(proc.pid)
        raise click.ClickException(str(registration_error)) from registration_error

    console.print(
        f"[green]OpenJarvis server starting[/green] (launch PID {proc.pid})\n"
        f"  Requested URL: {_server_url(bind_host, bind_port)}\n"
        f"  Log: {_LOG_FILE}"
    )

stop

stop() -> None

Stop the running OpenJarvis server daemon.

Source code in src/openjarvis/cli/daemon_cmd.py

@daemon.command()
def stop() -> None:
    """Stop the running OpenJarvis server daemon."""
    console = Console(stderr=True)
    pid = _read_pid()
    if pid is None:
        console.print("[yellow]No running server found.[/yellow]")
        sys.exit(1)

    # Graceful shutdown (SIGTERM / taskkill), escalating to a forced kill after
    # 10s if still running. Cross-platform — no POSIX-only os.kill/SIGKILL.
    terminate_process(pid, grace_seconds=10.0)

    clear_server_state(pid)
    console.print(f"[green]Server stopped[/green] (PID {pid}).")

restart

restart(ctx: Context) -> None

Restart the OpenJarvis server daemon.

Source code in src/openjarvis/cli/daemon_cmd.py

@daemon.command()
@click.pass_context
def restart(ctx: click.Context) -> None:
    """Restart the OpenJarvis server daemon."""
    console = Console(stderr=True)
    pid = _read_pid()
    previous = _read_state() if pid is not None else {}
    if previous.get("pid") != pid:
        previous = {}
    if pid is not None:
        console.print(f"Stopping server (PID {pid})...")
        ctx.invoke(stop)
    # Carry the previous bind address across the restart; otherwise an explicit
    # `start --port N` silently reverts to the config default on restart.
    ctx.invoke(
        start,
        host=previous.get("host") or None,
        port=previous.get("port"),
    )

status

status() -> None

Show status of the OpenJarvis server daemon.

Source code in src/openjarvis/cli/daemon_cmd.py

@daemon.command()
def status() -> None:
    """Show status of the OpenJarvis server daemon."""
    console = Console(stderr=True)
    pid = _read_pid()
    if pid is None:
        console.print("[yellow]Server is not running.[/yellow]")
        return

    state = _read_state()
    if state.get("pid") == pid and state.get("ready") is False:
        console.print(f"[yellow]Server is starting[/yellow] (PID {pid}).")
        console.print(f"  Log: {_LOG_FILE}")
        return

    # Get process info
    uptime_info = ""
    try:
        import psutil

        proc = psutil.Process(pid)
        uptime = time.time() - proc.create_time()
        hours, remainder = divmod(int(uptime), 3600)
        minutes, seconds = divmod(remainder, 60)
        uptime_info = f"\n  Uptime: {hours}h {minutes}m {seconds}s"
    except (ImportError, Exception):
        pass

    host, port = _bound_address(pid)
    console.print(
        f"[green]Server is running[/green] (PID {pid}){uptime_info}\n"
        f"  URL: {_server_url(host, port)}\n"
        f"  Log: {_LOG_FILE}"
    )