skypilot-nightly 1.0.0.dev2024053101__py3-none-any.whl → 1.0.0.dev2025022801__py3-none-any.whl

sky/cli.py

@@ -26,59 +26,66 @@ each other.
 import copy
 import datetime
 import functools
-import multiprocessing
+import getpass
 import os
 import shlex
-import signal
+import shutil
 import subprocess
 import sys
 import textwrap
-import time
+import traceback
 import typing
-from typing import Any, Dict, List, Optional, Tuple, Union
-import webbrowser
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Union
 
 import click
 import colorama
 import dotenv
+import requests as requests_lib
 from rich import progress as rich_progress
 import yaml
 
 import sky
 from sky import backends
-from sky import check as sky_check
-from sky import clouds as sky_clouds
-from sky import core
+from sky import clouds
 from sky import exceptions
 from sky import global_user_state
 from sky import jobs as managed_jobs
+from sky import models
 from sky import serve as serve_lib
 from sky import sky_logging
-from sky import status_lib
 from sky.adaptors import common as adaptors_common
-from sky.backends import backend_utils
 from sky.benchmark import benchmark_state
 from sky.benchmark import benchmark_utils
+from sky.client import sdk
 from sky.clouds import service_catalog
 from sky.data import storage_utils
+from sky.provision.kubernetes import constants as kubernetes_constants
 from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.server import common as server_common
+from sky.server import constants as server_constants
+from sky.server.requests import requests
 from sky.skylet import constants
 from sky.skylet import job_lib
-from sky.skylet import log_lib
 from sky.usage import usage_lib
+from sky.utils import annotations
+from sky.utils import cluster_utils
+from sky.utils import common
 from sky.utils import common_utils
 from sky.utils import controller_utils
 from sky.utils import dag_utils
+from sky.utils import env_options
 from sky.utils import log_utils
+from sky.utils import registry
 from sky.utils import resources_utils
 from sky.utils import rich_utils
+from sky.utils import status_lib
 from sky.utils import subprocess_utils
 from sky.utils import timeline
 from sky.utils import ux_utils
 from sky.utils.cli_utils import status_utils
 
 if typing.TYPE_CHECKING:
-    from sky.backends import backend as backend_lib
+    import types
 
 pd = adaptors_common.LazyImport('pandas')
 logger = sky_logging.init_logger(__name__)
@@ -98,23 +105,96 @@ _STATUS_PROPERTY_CLUSTER_NUM_ERROR_MESSAGE = (
     '{cluster_num} cluster{plural} {verb}. Please specify {cause} '
     'cluster to show its {property}.\nUsage: `sky status --{flag} <cluster>`')
 
-_ENDPOINTS_RETRY_MESSAGE = ('If the cluster was recently started, '
-                            'please retry after a while.')
-
 _DAG_NOT_SUPPORTED_MESSAGE = ('YAML specifies a DAG which is only supported by '
                               '`sky jobs launch`. `{command}` supports a '
                               'single task only.')
 
 
-def _get_glob_clusters(clusters: List[str], silent: bool = False) -> List[str]:
-    """Returns a list of clusters that match the glob pattern."""
-    glob_clusters = []
-    for cluster in clusters:
-        glob_cluster = global_user_state.get_glob_cluster_names(cluster)
-        if len(glob_cluster) == 0 and not silent:
-            click.echo(f'Cluster {cluster} not found.')
-        glob_clusters.extend(glob_cluster)
-    return list(set(glob_clusters))
+def _get_cluster_records_and_set_ssh_config(
+    clusters: Optional[List[str]],
+    refresh: common.StatusRefreshMode = common.StatusRefreshMode.NONE,
+    all_users: bool = False,
+) -> List[dict]:
+    """Returns a list of clusters that match the glob pattern.
+
+    Args:
+        clusters: A list of cluster names to query. If None, query all clusters.
+        refresh: The refresh mode for the status command.
+        all_users: Whether to query clusters from all users.
+            If clusters is not None, this field is ignored because cluster list
+            can include other users' clusters.
+    """
+    # TODO(zhwu): we should move this function into SDK.
+    # TODO(zhwu): this additional RTT makes CLIs slow. We should optimize this.
+    if clusters is not None:
+        all_users = True
+    request_id = sdk.status(clusters, refresh=refresh, all_users=all_users)
+    cluster_records = sdk.stream_and_get(request_id)
+    # Update the SSH config for all clusters
+    for record in cluster_records:
+        handle = record['handle']
+        # During the failover, even though a cluster does not exist, the handle
+        # can still exist in the record, and we check for credentials to avoid
+        # updating the SSH config for non-existent clusters.
+        if (handle is not None and handle.cached_external_ips is not None and
+                'credentials' in record):
+            credentials = record['credentials']
+            if isinstance(handle.launched_resources.cloud, clouds.Kubernetes):
+                # Replace the proxy command to proxy through the SkyPilot API
+                # server with websocket.
+                key_path = (
+                    cluster_utils.SSHConfigHelper.generate_local_key_file(
+                        handle.cluster_name, credentials))
+                # Instead of directly use websocket_proxy.py, we add an
+                # additional proxy, so that ssh can use the head pod in the
+                # cluster to jump to worker pods.
+                proxy_command = (
+                    f'ssh -tt -i {key_path} '
+                    '-o StrictHostKeyChecking=no '
+                    '-o UserKnownHostsFile=/dev/null '
+                    '-o IdentitiesOnly=yes '
+                    '-W %h:%p '
+                    f'{handle.ssh_user}@127.0.0.1 '
+                    '-o ProxyCommand='
+                    # TODO(zhwu): write the template to a temp file, don't use
+                    # the one in skypilot repo, to avoid changing the file when
+                    # updating skypilot.
+                    f'\'{sys.executable} {sky.__root_dir__}/templates/'
+                    f'websocket_proxy.py '
+                    f'{server_common.get_server_url().split("://")[1]} '
+                    f'{handle.cluster_name}\'')
+                credentials['ssh_proxy_command'] = proxy_command
+            cluster_utils.SSHConfigHelper.add_cluster(
+                handle.cluster_name,
+                handle.cached_external_ips,
+                credentials,
+                handle.cached_external_ssh_ports,
+                handle.docker_user,
+                handle.ssh_user,
+            )
+        else:
+            # If the cluster is not UP or does not have credentials available,
+            # we need to remove the cluster from the SSH config.
+            cluster_utils.SSHConfigHelper.remove_cluster(record['name'])
+
+    # Clean up SSH configs for clusters that do not exist.
+    #
+    # We do this in a conservative way: only when a query is made for all users
+    # or specific clusters. Without those, the table returned only contains the
+    # current user's clusters, and the information is not enough for
+    # removing clusters, because SkyPilot has no idea whether to remove
+    # ssh config of a cluster from another user.
+    clusters_exists = set(record['name'] for record in cluster_records)
+    if clusters is not None:
+        for cluster in clusters:
+            if cluster not in clusters_exists:
+                cluster_utils.SSHConfigHelper.remove_cluster(cluster)
+    elif all_users:
+        for cluster_name in cluster_utils.SSHConfigHelper.list_cluster_names():
+            if cluster_name not in clusters_exists:
+                cluster_utils.SSHConfigHelper.remove_cluster(cluster_name)
+
+    return cluster_records
 
 
 def _get_glob_storages(storages: List[str]) -> List[str]:
@@ -122,7 +202,7 @@ def _get_glob_storages(storages: List[str]) -> List[str]:
     glob_storages = []
     for storage_object in storages:
         glob_storage = global_user_state.get_glob_storage_name(storage_object)
-        if len(glob_storage) == 0:
+        if not glob_storage:
             click.echo(f'Storage {storage_object} not found.')
         glob_storages.extend(glob_storage)
     return list(set(glob_storages))
@@ -144,6 +224,44 @@ def _parse_env_var(env_var: str) -> Tuple[str, str]:
     return ret[0], ret[1]
 
 
+def _async_call_or_wait(request_id: str, async_call: bool,
+                        request_name: str) -> Any:
+    short_request_id = request_id[:8]
+    if not async_call:
+        try:
+            return sdk.stream_and_get(request_id)
+        except KeyboardInterrupt:
+            logger.info(
+                ux_utils.starting_message('Request will continue running '
+                                          'asynchronously.') +
+                f'\n{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}View logs: '
+                f'{ux_utils.BOLD}sky api logs {short_request_id}'
+                f'{colorama.Style.RESET_ALL}'
+                f'\n{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Or, '
+                'visit: '
+                f'{server_common.get_server_url()}/api/stream?'
+                f'request_id={short_request_id}'
+                f'\n{ux_utils.INDENT_LAST_SYMBOL}{colorama.Style.DIM}To cancel '
+                'the request, run: '
+                f'{ux_utils.BOLD}sky api cancel {short_request_id}'
+                f'{colorama.Style.RESET_ALL}'
+                f'\n{colorama.Style.RESET_ALL}')
+            raise
+    else:
+        click.secho(f'Submitted {request_name} request: {request_id}',
+                    fg='green')
+        click.echo(
+            f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Check logs with: '
+            f'sky api logs {short_request_id}{colorama.Style.RESET_ALL}\n'
+            f'{ux_utils.INDENT_SYMBOL}{colorama.Style.DIM}Or, visit: '
+            f'{server_common.get_server_url()}/api/stream?'
+            f'request_id={short_request_id}'
+            f'\n{ux_utils.INDENT_LAST_SYMBOL}{colorama.Style.DIM}To cancel '
+            'the request, run: '
+            f'{ux_utils.BOLD}sky api cancel {short_request_id}'
+            f'{colorama.Style.RESET_ALL}\n')
+
+
 def _merge_env_vars(env_dict: Optional[Dict[str, str]],
                     env_list: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
     """Merges all values from env_list into env_dict."""
@@ -154,6 +272,15 @@ def _merge_env_vars(env_dict: Optional[Dict[str, str]],
     return list(env_dict.items())
 
 
+_COMMON_OPTIONS = [
+    click.option('--async/--no-async',
+                 'async_call',
+                 required=False,
+                 is_flag=True,
+                 default=False,
+                 help=('Run the command asynchronously.'))
+]
+
 _TASK_OPTIONS = [
     click.option(
         '--workdir',
@@ -305,14 +432,28 @@ def _complete_cluster_name(ctx: click.Context, param: click.Parameter,
                            incomplete: str) -> List[str]:
     """Handle shell completion for cluster names."""
     del ctx, param  # Unused.
-    return global_user_state.get_cluster_names_start_with(incomplete)
+    # TODO(zhwu): we send requests to API server for completion, which can cause
+    # large latency. We should investigate caching mechanism if needed.
+    response = requests_lib.get(
+        f'{server_common.get_server_url()}'
+        f'/api/completion/cluster_name?incomplete={incomplete}',
+        timeout=2.0,
+    )
+    response.raise_for_status()
+    return response.json()
 
 
 def _complete_storage_name(ctx: click.Context, param: click.Parameter,
                            incomplete: str) -> List[str]:
     """Handle shell completion for storage names."""
     del ctx, param  # Unused.
-    return global_user_state.get_storage_names_start_with(incomplete)
+    response = requests_lib.get(
+        f'{server_common.get_server_url()}'
+        f'/api/completion/storage_name?incomplete={incomplete}',
+        timeout=2.0,
+    )
+    response.raise_for_status()
+    return response.json()
 
 
 def _complete_file_name(ctx: click.Context, param: click.Parameter,
@@ -338,7 +479,6 @@ def _get_shell_complete_args(complete_fn):
 
 
 _RELOAD_ZSH_CMD = 'source ~/.zshrc'
-_RELOAD_FISH_CMD = 'source ~/.config/fish/config.fish'
 _RELOAD_BASH_CMD = 'source ~/.bashrc'
 
 
@@ -368,14 +508,18 @@ def _install_shell_completion(ctx: click.Context, param: click.Parameter,
                 echo "{bashrc_diff}" >> ~/.bashrc'
 
         cmd = (f'(grep -q "SkyPilot" ~/.bashrc) || '
-               f'[[ ${{BASH_VERSINFO[0]}} -ge 4 ]] && ({install_cmd})')
+               f'([[ ${{BASH_VERSINFO[0]}} -ge 4 ]] && ({install_cmd}) || '
+               f'(echo "Bash must be version 4 or above." && exit 1))')
+
         reload_cmd = _RELOAD_BASH_CMD
 
     elif value == 'fish':
         cmd = '_SKY_COMPLETE=fish_source sky > \
                 ~/.config/fish/completions/sky.fish'
 
-        reload_cmd = _RELOAD_FISH_CMD
+        # Fish does not need to be reloaded and will automatically pick up
+        # completions.
+        reload_cmd = None
 
     elif value == 'zsh':
         install_cmd = f'_SKY_COMPLETE=zsh_source sky > \
@@ -390,11 +534,15 @@ def _install_shell_completion(ctx: click.Context, param: click.Parameter,
         ctx.exit()
 
     try:
-        subprocess.run(cmd, shell=True, check=True, executable='/bin/bash')
+        subprocess.run(cmd,
+                       shell=True,
+                       check=True,
+                       executable=shutil.which('bash'))
         click.secho(f'Shell completion installed for {value}', fg='green')
-        click.echo(
-            'Completion will take effect once you restart the terminal: ' +
-            click.style(f'{reload_cmd}', bold=True))
+        if reload_cmd is not None:
+            click.echo(
+                'Completion will take effect once you restart the terminal: ' +
+                click.style(f'{reload_cmd}', bold=True))
     except subprocess.CalledProcessError as e:
         click.secho(f'> Installation failed with code {e.returncode}', fg='red')
     ctx.exit()
@@ -425,7 +573,9 @@ def _uninstall_shell_completion(ctx: click.Context, param: click.Parameter,
 
     elif value == 'fish':
         cmd = 'rm -f ~/.config/fish/completions/sky.fish'
-        reload_cmd = _RELOAD_FISH_CMD
+        # Fish does not need to be reloaded and will automatically pick up
+        # completions.
+        reload_cmd = None
 
     elif value == 'zsh':
         cmd = 'sed -i"" -e "/# For SkyPilot shell completion/d" ~/.zshrc && \
@@ -441,8 +591,10 @@ def _uninstall_shell_completion(ctx: click.Context, param: click.Parameter,
     try:
         subprocess.run(cmd, shell=True, check=True)
         click.secho(f'Shell completion uninstalled for {value}', fg='green')
-        click.echo('Changes will take effect once you restart the terminal: ' +
-                   click.style(f'{reload_cmd}', bold=True))
+        if reload_cmd is not None:
+            click.echo(
+                'Changes will take effect once you restart the terminal: ' +
+                click.style(f'{reload_cmd}', bold=True))
     except subprocess.CalledProcessError as e:
         click.secho(f'> Uninstallation failed with code {e.returncode}',
                     fg='red')
@@ -472,14 +624,14 @@ def _parse_override_params(
         image_id: Optional[str] = None,
         disk_size: Optional[int] = None,
         disk_tier: Optional[str] = None,
-        ports: Optional[Tuple[str]] = None) -> Dict[str, Any]:
+        ports: Optional[Tuple[str, ...]] = None) -> Dict[str, Any]:
     """Parses the override parameters into a dictionary."""
     override_params: Dict[str, Any] = {}
     if cloud is not None:
         if cloud.lower() == 'none':
             override_params['cloud'] = None
         else:
-            override_params['cloud'] = sky_clouds.CLOUD_REGISTRY.from_str(cloud)
+            override_params['cloud'] = registry.CLOUD_REGISTRY.from_str(cloud)
     if region is not None:
         if region.lower() == 'none':
             override_params['region'] = None
@@ -525,91 +677,17 @@ def _parse_override_params(
         else:
             override_params['disk_tier'] = disk_tier
     if ports:
-        override_params['ports'] = ports
+        if any(p.lower() == 'none' for p in ports):
+            if len(ports) > 1:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError('Cannot specify both "none" and other '
+                                     'ports.')
+            override_params['ports'] = None
+        else:
+            override_params['ports'] = ports
     return override_params
 
 
-def _launch_with_confirm(
-    task: sky.Task,
-    backend: backends.Backend,
-    cluster: Optional[str],
-    *,
-    dryrun: bool,
-    detach_run: bool,
-    detach_setup: bool = False,
-    no_confirm: bool = False,
-    idle_minutes_to_autostop: Optional[int] = None,
-    down: bool = False,  # pylint: disable=redefined-outer-name
-    retry_until_up: bool = False,
-    no_setup: bool = False,
-    clone_disk_from: Optional[str] = None,
-):
-    """Launch a cluster with a Task."""
-    if cluster is None:
-        cluster = backend_utils.generate_cluster_name()
-
-    clone_source_str = ''
-    if clone_disk_from is not None:
-        clone_source_str = f' from the disk of {clone_disk_from!r}'
-        task, _ = backend_utils.check_can_clone_disk_and_override_task(
-            clone_disk_from, cluster, task)
-
-    with sky.Dag() as dag:
-        dag.add(task)
-
-    maybe_status, handle = backend_utils.refresh_cluster_status_handle(cluster)
-    if maybe_status is None:
-        # Show the optimize log before the prompt if the cluster does not exist.
-        try:
-            sky_check.get_cached_enabled_clouds_or_refresh(
-                raise_if_no_cloud_access=True)
-        except exceptions.NoCloudAccessError as e:
-            # Catch the exception where the public cloud is not enabled, and
-            # make it yellow for better visibility.
-            with ux_utils.print_exception_no_traceback():
-                raise RuntimeError(f'{colorama.Fore.YELLOW}{e}'
-                                   f'{colorama.Style.RESET_ALL}') from e
-        dag = sky.optimize(dag)
-    task = dag.tasks[0]
-
-    if handle is not None:
-        backend.check_resources_fit_cluster(handle, task)
-
-    confirm_shown = False
-    if not no_confirm:
-        # Prompt if (1) --cluster is None, or (2) cluster doesn't exist, or (3)
-        # it exists but is STOPPED.
-        prompt = None
-        if maybe_status is None:
-            cluster_str = '' if cluster is None else f' {cluster!r}'
-            prompt = (
-                f'Launching a new cluster{cluster_str}{clone_source_str}. '
-                'Proceed?')
-        elif maybe_status == status_lib.ClusterStatus.STOPPED:
-            prompt = f'Restarting the stopped cluster {cluster!r}. Proceed?'
-        if prompt is not None:
-            confirm_shown = True
-            click.confirm(prompt, default=True, abort=True, show_default=True)
-
-    if not confirm_shown:
-        click.secho(f'Running task on cluster {cluster}...', fg='yellow')
-
-    sky.launch(
-        dag,
-        dryrun=dryrun,
-        stream_logs=True,
-        cluster_name=cluster,
-        detach_setup=detach_setup,
-        detach_run=detach_run,
-        backend=backend,
-        idle_minutes_to_autostop=idle_minutes_to_autostop,
-        down=down,
-        retry_until_up=retry_until_up,
-        no_setup=no_setup,
-        clone_disk_from=clone_disk_from,
-    )
-
-
 def _check_yaml(entrypoint: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
     """Checks if entrypoint is a readable YAML file.
 
@@ -690,7 +768,6 @@ def _pop_and_ignore_fields_in_override_params(
 def _make_task_or_dag_from_entrypoint_with_overrides(
     entrypoint: Tuple[str, ...],
     *,
-    entrypoint_name: str = 'Task',
     name: Optional[str] = None,
     workdir: Optional[str] = None,
     cloud: Optional[str] = None,
@@ -705,7 +782,7 @@ def _make_task_or_dag_from_entrypoint_with_overrides(
     image_id: Optional[str] = None,
     disk_size: Optional[int] = None,
     disk_tier: Optional[str] = None,
-    ports: Optional[Tuple[str]] = None,
+    ports: Optional[Tuple[str, ...]] = None,
     env: Optional[List[Tuple[str, str]]] = None,
     field_to_ignore: Optional[List[str]] = None,
     # job launch specific
@@ -722,19 +799,15 @@ def _make_task_or_dag_from_entrypoint_with_overrides(
     entrypoint: Optional[str]
     if is_yaml:
         # Treat entrypoint as a yaml.
-        click.secho(f'{entrypoint_name} from YAML spec: ',
-                    fg='yellow',
-                    nl=False)
-        click.secho(entrypoint, bold=True)
+        click.secho('YAML to run: ', fg='cyan', nl=False)
+        click.secho(entrypoint)
     else:
         if not entrypoint:
             entrypoint = None
         else:
             # Treat entrypoint as a bash command.
-            click.secho(f'{entrypoint_name} from command: ',
-                        fg='yellow',
-                        nl=False)
-            click.secho(entrypoint, bold=True)
+            click.secho('Command to run: ', fg='cyan', nl=False)
+            click.secho(entrypoint)
 
     override_params = _parse_override_params(cloud=cloud,
                                              region=region,
@@ -798,7 +871,7 @@ class _NaturalOrderGroup(click.Group):
     Reference: https://github.com/pallets/click/issues/513
     """
 
-    def list_commands(self, ctx):
+    def list_commands(self, ctx):  # pylint: disable=unused-argument
         return self.commands.keys()
 
     @usage_lib.entrypoint('sky.cli', fallback=True)
@@ -925,6 +998,7 @@ def _deprecate_and_hide_command(group, command_to_deprecate,
                       prog_name='skypilot',
                       message='%(prog)s, commit %(version)s',
                       help='Show the commit hash and exit')
+@annotations.client_api
 def cli():
     pass
 
@@ -945,20 +1019,9 @@ def cli():
               default=False,
               is_flag=True,
               help='If True, do not actually run the job.')
-@click.option(
-    '--detach-setup',
-    '-s',
-    default=False,
-    is_flag=True,
-    help=
-    ('If True, run setup in non-interactive mode as part of the job itself. '
-     'You can safely ctrl-c to detach from logging, and it will not interrupt '
-     'the setup process. To see the logs again after detaching, use `sky logs`.'
-     ' To cancel setup, cancel the job via `sky cancel`. Useful for long-'
-     'running setup commands.'))
 @click.option(
     '--detach-run',
-    '-d',
+    '-d/-no-d',
     default=False,
     is_flag=True,
     help=('If True, as soon as a job is submitted, return from this call '
@@ -967,8 +1030,12 @@ def cli():
               'backend_name',
               flag_value=backends.LocalDockerBackend.NAME,
               default=False,
-              help='If used, runs locally inside a docker container.')
-@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS)
+              hidden=True,
+              help=('(Deprecated) Local docker support is deprecated. '
+                    'To run locally, create a local Kubernetes cluster with '
+                    '``sky local up``.'))
+@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS +
+                    _COMMON_OPTIONS)
 @click.option(
     '--idle-minutes-to-autostop',
     '-i',
@@ -1028,38 +1095,45 @@ def cli():
     help=('[Experimental] Clone disk from an existing cluster to launch '
           'a new one. This is useful when the new cluster needs to have '
           'the same data on the boot disk as an existing cluster.'))
+@click.option(
+    '--fast',
+    is_flag=True,
+    default=False,
+    required=False,
+    help=('[Experimental] If the cluster is already up and available, skip '
+          'provisioning and setup steps.'))
 @usage_lib.entrypoint
 def launch(
-    entrypoint: Tuple[str, ...],
-    cluster: Optional[str],
-    dryrun: bool,
-    detach_setup: bool,
-    detach_run: bool,
-    backend_name: Optional[str],
-    name: Optional[str],
-    workdir: Optional[str],
-    cloud: Optional[str],
-    region: Optional[str],
-    zone: Optional[str],
-    gpus: Optional[str],
-    cpus: Optional[str],
-    memory: Optional[str],
-    instance_type: Optional[str],
-    num_nodes: Optional[int],
-    use_spot: Optional[bool],
-    image_id: Optional[str],
-    env_file: Optional[Dict[str, str]],
-    env: List[Tuple[str, str]],
-    disk_size: Optional[int],
-    disk_tier: Optional[str],
-    ports: Tuple[str],
-    idle_minutes_to_autostop: Optional[int],
-    down: bool,  # pylint: disable=redefined-outer-name
-    retry_until_up: bool,
-    yes: bool,
-    no_setup: bool,
-    clone_disk_from: Optional[str],
-):
+        entrypoint: Tuple[str, ...],
+        cluster: Optional[str],
+        dryrun: bool,
+        detach_run: bool,
+        backend_name: Optional[str],
+        name: Optional[str],
+        workdir: Optional[str],
+        cloud: Optional[str],
+        region: Optional[str],
+        zone: Optional[str],
+        gpus: Optional[str],
+        cpus: Optional[str],
+        memory: Optional[str],
+        instance_type: Optional[str],
+        num_nodes: Optional[int],
+        use_spot: Optional[bool],
+        image_id: Optional[str],
+        env_file: Optional[Dict[str, str]],
+        env: List[Tuple[str, str]],
+        disk_size: Optional[int],
+        disk_tier: Optional[str],
+        ports: Tuple[str, ...],
+        idle_minutes_to_autostop: Optional[int],
+        down: bool,  # pylint: disable=redefined-outer-name
+        retry_until_up: bool,
+        yes: bool,
+        no_setup: bool,
+        clone_disk_from: Optional[str],
+        fast: bool,
+        async_call: bool):
     """Launch a cluster or task.
 
     If ENTRYPOINT points to a valid YAML file, it is read in as the task
@@ -1069,6 +1143,14 @@ def launch(
     and they undergo job queue scheduling.
     """
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
+    # TODO(zhwu): the current --async is a bit inconsistent with the direct
+    # sky launch, as `sky api logs` does not contain the logs for the actual job
+    # submitted, while the synchronous way of `sky launch` does. We should
+    # consider having the job logs available in `sky api logs` as well.
+    # Reason for not doing it right now: immediately tailing the logs for the
+    # job can take up resources on the API server. When there are a lot of
+    # `launch` submitted asynchronously, the log tailing may overwhelm the API
+    # server, if the jobs are long running.
     env = _merge_env_vars(env_file, env)
     controller_utils.check_cluster_name_not_controller(
         cluster, operation_str='Launching tasks on it')
@@ -1102,6 +1184,11 @@ def launch(
     backend: backends.Backend
     if backend_name == backends.LocalDockerBackend.NAME:
         backend = backends.LocalDockerBackend()
+        click.secho(
+            'WARNING: LocalDockerBackend is deprecated and will be '
+            'removed in a future release. To run locally, create a local '
+            'Kubernetes cluster with `sky local up`.',
+            fg='yellow')
     elif backend_name == backends.CloudVmRayBackend.NAME:
         backend = backends.CloudVmRayBackend()
     else:
@@ -1116,18 +1203,35 @@ def launch(
             f'{colorama.Style.RESET_ALL}{colorama.Style.BRIGHT}sky serve up'
             f'{colorama.Style.RESET_ALL}')
 
-    _launch_with_confirm(task,
-                         backend,
-                         cluster,
-                         dryrun=dryrun,
-                         detach_setup=detach_setup,
-                         detach_run=detach_run,
-                         no_confirm=yes,
-                         idle_minutes_to_autostop=idle_minutes_to_autostop,
-                         down=down,
-                         retry_until_up=retry_until_up,
-                         no_setup=no_setup,
-                         clone_disk_from=clone_disk_from)
+    request_id = sdk.launch(
+        task,
+        dryrun=dryrun,
+        cluster_name=cluster,
+        backend=backend,
+        idle_minutes_to_autostop=idle_minutes_to_autostop,
+        down=down,
+        retry_until_up=retry_until_up,
+        no_setup=no_setup,
+        clone_disk_from=clone_disk_from,
+        fast=fast,
+        _need_confirmation=not yes,
+    )
+    job_id_handle = _async_call_or_wait(request_id, async_call, 'sky.launch')
+    if not async_call:
+        job_id, handle = job_id_handle
+        if not handle:
+            assert dryrun, 'handle should only be None when dryrun is true'
+            return
+        # Add ssh config for the cluster
+        _get_cluster_records_and_set_ssh_config(
+            clusters=[handle.get_cluster_name()])
+        # job_id will be None if no job was submitted (e.g. no entrypoint
+        # provided)
+        if not detach_run and job_id is not None:
+            sdk.tail_logs(handle.get_cluster_name(), job_id, follow=True)
+        click.secho(
+            ux_utils.command_hint_messages(ux_utils.CommandHintType.CLUSTER_JOB,
+                                           job_id, handle.get_cluster_name()))
 
 
 @cli.command(cls=_DocumentedCodeCommand)
@@ -1155,32 +1259,19 @@ def launch(
     is_flag=True,
     help=('If True, as soon as a job is submitted, return from this call '
           'and do not stream execution logs.'))
-@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS)
+@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS +
+                    _COMMON_OPTIONS)
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def exec(
-    cluster: Optional[str],
-    cluster_option: Optional[str],
-    entrypoint: Tuple[str, ...],
-    detach_run: bool,
-    name: Optional[str],
-    cloud: Optional[str],
-    region: Optional[str],
-    zone: Optional[str],
-    workdir: Optional[str],
-    gpus: Optional[str],
-    ports: Tuple[str],
-    instance_type: Optional[str],
-    num_nodes: Optional[int],
-    use_spot: Optional[bool],
-    image_id: Optional[str],
-    env_file: Optional[Dict[str, str]],
-    env: List[Tuple[str, str]],
-    cpus: Optional[str],
-    memory: Optional[str],
-    disk_size: Optional[int],
-    disk_tier: Optional[str],
-):
+def exec(cluster: Optional[str], cluster_option: Optional[str],
+         entrypoint: Tuple[str, ...], detach_run: bool, name: Optional[str],
+         cloud: Optional[str], region: Optional[str], zone: Optional[str],
+         workdir: Optional[str], gpus: Optional[str], ports: Tuple[str],
+         instance_type: Optional[str], num_nodes: Optional[int],
+         use_spot: Optional[bool], image_id: Optional[str],
+         env_file: Optional[Dict[str, str]], env: List[Tuple[str, str]],
+         cpus: Optional[str], memory: Optional[str], disk_size: Optional[int],
+         disk_tier: Optional[str], async_call: bool):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Execute a task or command on an existing cluster.
 
@@ -1253,11 +1344,6 @@ def exec(
     env = _merge_env_vars(env_file, env)
     controller_utils.check_cluster_name_not_controller(
         cluster, operation_str='Executing task on it')
-    handle = global_user_state.get_handle_from_cluster_name(cluster)
-    if handle is None:
-        raise click.BadParameter(f'Cluster {cluster!r} not found. '
-                                 'Use `sky launch` to provision first.')
-    backend = backend_utils.get_backend_from_handle(handle)
 
     task_or_dag = _make_task_or_dag_from_entrypoint_with_overrides(
         entrypoint=entrypoint,
@@ -1285,23 +1371,26 @@ def exec(
                                'supports a single task only.')
     task = task_or_dag
 
-    click.secho(f'Executing task on cluster {cluster}...', fg='yellow')
-    sky.exec(task, backend=backend, cluster_name=cluster, detach_run=detach_run)
+    click.secho('Submitting job to cluster: ', fg='cyan', nl=False)
+    click.secho(cluster)
+    request_id = sdk.exec(task, cluster_name=cluster)
+    job_id_handle = _async_call_or_wait(request_id, async_call, 'sky.exec')
+    if not async_call and not detach_run:
+        job_id, _ = job_id_handle
+        sdk.tail_logs(cluster, job_id, follow=True)
 
 
-def _get_managed_jobs(
-        refresh: bool,
-        skip_finished: bool,
+def _handle_jobs_queue_request(
+        request_id: str,
         show_all: bool,
+        show_user: bool,
         limit_num_jobs_to_show: bool = False,
         is_called_by_user: bool = False) -> Tuple[Optional[int], str]:
     """Get the in-progress managed jobs.
 
     Args:
-        refresh: Query the latest statuses, restarting the jobs controller if
-            stopped.
-        skip_finished: Show only in-progress jobs.
         show_all: Show all information of each job (e.g., region, price).
+        show_user: Show the user who submitted the job.
         limit_num_jobs_to_show: If True, limit the number of jobs to show to
             _NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS, which is mainly used by
             `sky status`.
@@ -1314,14 +1403,13 @@ def _get_managed_jobs(
         msg contains the error message. Otherwise, msg contains the formatted
         managed job table.
     """
+    # TODO(SKY-980): remove unnecessary fallbacks on the client side.
     num_in_progress_jobs = None
+    msg = ''
     try:
         if not is_called_by_user:
             usage_lib.messages.usage.set_internal()
-        with sky_logging.silent():
-            # Make the call silent
-            managed_jobs_ = managed_jobs.queue(refresh=refresh,
-                                               skip_finished=skip_finished)
+        managed_jobs_ = sdk.get(request_id)
         num_in_progress_jobs = len(set(job['job_id'] for job in managed_jobs_))
     except exceptions.ClusterNotUpError as e:
         controller_status = e.cluster_status
@@ -1334,17 +1422,19 @@ def _get_managed_jobs(
             msg += (f' (See finished managed jobs: {colorama.Style.BRIGHT}'
                     f'sky jobs queue --refresh{colorama.Style.RESET_ALL})')
     except RuntimeError as e:
-        msg = ''
         try:
             # Check the controller status again, as the RuntimeError is likely
             # due to the controller being autostopped when querying the jobs.
-            controller_type = controller_utils.Controllers.JOBS_CONTROLLER
-            record = backend_utils.refresh_cluster_record(
-                controller_type.value.cluster_name,
-                cluster_status_lock_timeout=0)
-            if (record is None or
-                    record['status'] == status_lib.ClusterStatus.STOPPED):
-                msg = controller_type.value.default_hint_if_non_existent
+            # Since we are client-side, we may not know the exact name of the
+            # controller, so use the prefix with a wildcard.
+            # Query status of the controller cluster.
+            records = sdk.get(
+                sdk.status(cluster_names=[common.JOB_CONTROLLER_PREFIX + '*'],
+                           all_users=True))
+            if (not records or
+                    records[0]['status'] == status_lib.ClusterStatus.STOPPED):
+                controller = controller_utils.Controllers.JOBS_CONTROLLER.value
+                msg = controller.default_hint_if_non_existent
         except Exception:  # pylint: disable=broad-except
             # This is to an best effort to find the latest controller status to
             # print more helpful message, so we can ignore any exception to
@@ -1357,21 +1447,28 @@ def _get_managed_jobs(
                 f'Details: {common_utils.format_exception(e, use_bracket=True)}'
             )
     except Exception as e:  # pylint: disable=broad-except
-        msg = ('Failed to query managed jobs: '
-               f'{common_utils.format_exception(e, use_bracket=True)}')
+        msg = ''
+        if env_options.Options.SHOW_DEBUG_INFO.get():
+            msg += traceback.format_exc()
+            msg += '\n'
+        msg += ('Failed to query managed jobs: '
+                f'{common_utils.format_exception(e, use_bracket=True)}')
     else:
         max_jobs_to_show = (_NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS
                             if limit_num_jobs_to_show else None)
         msg = managed_jobs.format_job_table(managed_jobs_,
                                             show_all=show_all,
+                                            show_user=show_user,
                                             max_jobs=max_jobs_to_show)
     return num_in_progress_jobs, msg
 
 
-def _get_services(service_names: Optional[List[str]],
-                  show_all: bool,
-                  show_endpoint: bool,
-                  is_called_by_user: bool = False) -> Tuple[Optional[int], str]:
+def _handle_services_request(
+        request_id: str,
+        service_names: Optional[List[str]],
+        show_all: bool,
+        show_endpoint: bool,
+        is_called_by_user: bool = False) -> Tuple[Optional[int], str]:
     """Get service statuses.
 
     Args:
@@ -1390,12 +1487,8 @@ def _get_services(service_names: Optional[List[str]],
     try:
         if not is_called_by_user:
             usage_lib.messages.usage.set_internal()
-        with sky_logging.silent():
-            if not service_names:
-                # Change empty list to None
-                service_names = None
-            service_records = serve_lib.status(service_names)
-            num_services = len(service_records)
+        service_records = sdk.get(request_id)
+        num_services = len(service_records)
     except exceptions.ClusterNotUpError as e:
         controller_status = e.cluster_status
         msg = str(e)
@@ -1408,13 +1501,18 @@ def _get_services(service_names: Optional[List[str]],
             # Check the controller status again, as the RuntimeError is likely
             # due to the controller being autostopped when querying the
             # services.
-            controller_type = controller_utils.Controllers.SKY_SERVE_CONTROLLER
-            record = backend_utils.refresh_cluster_record(
-                controller_type.value.cluster_name,
-                cluster_status_lock_timeout=0)
-            if (record is None or
-                    record['status'] == status_lib.ClusterStatus.STOPPED):
-                msg = controller_type.value.default_hint_if_non_existent
+            # Since we are client-side, we may not know the exact name of the
+            # controller, so use the prefix with a wildcard.
+            # Query status of the controller cluster.
+            records = sdk.get(
+                sdk.status(
+                    cluster_names=[common.SKY_SERVE_CONTROLLER_PREFIX + '*'],
+                    all_users=True))
+            if (not records or
+                    records[0]['status'] == status_lib.ClusterStatus.STOPPED):
+                controller = (
+                    controller_utils.Controllers.SKY_SERVE_CONTROLLER.value)
+                msg = controller.default_hint_if_non_existent
         except Exception:  # pylint: disable=broad-except
             # This is to an best effort to find the latest controller status to
             # print more helpful message, so we can ignore any exception to
@@ -1432,12 +1530,13 @@ def _get_services(service_names: Optional[List[str]],
             if len(service_records) != 1:
                 plural = 's' if len(service_records) > 1 else ''
                 service_num = (str(len(service_records))
-                               if len(service_records) > 0 else 'No')
+                               if service_records else 'No')
                 raise click.UsageError(
                     f'{service_num} service{plural} found. Please specify '
                     'an existing service to show its endpoint. Usage: '
                     'sky serve status --endpoint <service-name>')
-            msg = serve_lib.get_endpoint(service_records[0])
+            endpoint = service_records[0]['endpoint']
+            msg = '-' if endpoint is None else endpoint
         else:
             msg = serve_lib.format_service_table(service_records, show_all)
             service_not_found_msg = ''
@@ -1452,9 +1551,105 @@ def _get_services(service_names: Optional[List[str]],
     return num_services, msg
 
 
+def _status_kubernetes(show_all: bool):
+    """Show all SkyPilot resources in the current Kubernetes context.
+
+    Args:
+        show_all (bool): Show all job information (e.g., start time, failures).
+    """
+    all_clusters, unmanaged_clusters, all_jobs, context = (sdk.stream_and_get(
+        sdk.status_kubernetes()))
+    click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+               f'Kubernetes cluster state (context: {context})'
+               f'{colorama.Style.RESET_ALL}')
+    status_utils.show_kubernetes_cluster_status_table(unmanaged_clusters,
+                                                      show_all)
+    if all_jobs:
+        click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                   f'Managed jobs'
+                   f'{colorama.Style.RESET_ALL}')
+        msg = managed_jobs.format_job_table(all_jobs,
+                                            show_all=show_all,
+                                            show_user=False)
+        click.echo(msg)
+    if any(['sky-serve-controller' in c.cluster_name for c in all_clusters]):
+        # TODO: Parse serve controllers and show services separately.
+        #  Currently we show a hint that services are shown as clusters.
+        click.echo(f'\n{colorama.Style.DIM}Hint: SkyServe replica pods are '
+                   'shown in the "SkyPilot clusters" section.'
+                   f'{colorama.Style.RESET_ALL}')
+
+
+def _show_endpoint(query_clusters: Optional[List[str]],
+                   cluster_records: List[Dict[str, Any]], ip: bool,
+                   endpoints: bool, endpoint: Optional[int]) -> None:
+    show_endpoints = endpoints or endpoint is not None
+    show_single_endpoint = endpoint is not None
+    if len(cluster_records) != 1:
+        with ux_utils.print_exception_no_traceback():
+            plural = 's' if len(cluster_records) > 1 else ''
+            if cluster_records:
+                cluster_num = str(len(cluster_records))
+            else:
+                cluster_num = (f'{query_clusters[0]!r}'
+                               if query_clusters else 'No')
+            verb = 'found' if cluster_records else 'not found'
+            cause = 'a single'
+            if query_clusters and len(query_clusters) > 1:
+                cause = 'an existing'
+            raise ValueError(
+                _STATUS_PROPERTY_CLUSTER_NUM_ERROR_MESSAGE.format(
+                    cluster_num=cluster_num,
+                    plural=plural,
+                    verb=verb,
+                    cause=cause,
+                    property='IP address' if ip else 'endpoint(s)',
+                    flag='ip' if ip else
+                    ('endpoint port' if show_single_endpoint else 'endpoints')))
+
+    cluster_record = cluster_records[0]
+    if cluster_record['status'] != status_lib.ClusterStatus.UP:
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(f'Cluster {cluster_record["name"]!r} '
+                               'is not in UP status.')
+    handle = cluster_record['handle']
+    if not isinstance(handle, backends.CloudVmRayResourceHandle):
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Querying IP address is not supported '
+                             'for local clusters.')
+
+    head_ip = handle.external_ips()[0]
+    # The endpoint request is relatively fast, so we don't add special handling
+    # for keyboard interrupt and abort the request to avoid additional latency.
+    if show_endpoints:
+        if endpoint:
+            request_id = sdk.endpoints(cluster_record['name'], endpoint)
+            cluster_endpoints = sdk.stream_and_get(request_id)
+            cluster_endpoint = cluster_endpoints.get(str(endpoint), None)
+            if not cluster_endpoint:
+                raise click.Abort(f'Endpoint {endpoint} not found for cluster '
+                                  f'{cluster_record["name"]!r}.')
+            click.echo(cluster_endpoint)
+        else:
+            request_id = sdk.endpoints(cluster_record['name'])
+            cluster_endpoints = sdk.stream_and_get(request_id)
+            assert isinstance(cluster_endpoints, dict)
+            if not cluster_endpoints:
+                raise click.Abort(f'No endpoint found for cluster '
+                                  f'{cluster_record["name"]!r}.')
+            for port, port_endpoint in cluster_endpoints.items():
+                click.echo(f'{colorama.Fore.BLUE}{colorama.Style.BRIGHT}{port}'
+                           f'{colorama.Style.RESET_ALL}: '
+                           f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                           f'{port_endpoint}{colorama.Style.RESET_ALL}')
+        return
+    click.echo(head_ip)
+    return
+
+
 @cli.command()
-@click.option('--all',
-              '-a',
+@click.option('--verbose',
+              '-v',
               default=False,
               is_flag=True,
               required=False,
@@ -1497,16 +1692,32 @@ def _get_services(service_names: Optional[List[str]],
               is_flag=True,
               required=False,
               help='Also show sky serve services, if any.')
+@click.option(
+    '--kubernetes',
+    '--k8s',
+    default=False,
+    is_flag=True,
+    required=False,
+    help='[Experimental] Show all SkyPilot resources (including from other '
+    'users) in the current Kubernetes context.')
 @click.argument('clusters',
                 required=False,
                 type=str,
                 nargs=-1,
                 **_get_shell_complete_args(_complete_cluster_name))
+@click.option('--all-users',
+              '-u',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Show all clusters, including those not owned by the '
+              'current user.')
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
+def status(verbose: bool, refresh: bool, ip: bool, endpoints: bool,
            endpoint: Optional[int], show_managed_jobs: bool,
-           show_services: bool, clusters: List[str]):
+           show_services: bool, kubernetes: bool, clusters: List[str],
+           all_users: bool):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Show clusters.
 
@@ -1521,11 +1732,15 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
     ``sky status --endpoints mycluster``. To query a single endpoint, you
     can use ``sky status mycluster --endpoint 8888``.
 
+    Running `sky status` will update the ssh config for the clusters locally, so
+    that you can directly ssh into the clusters or connect to the clusters with
+    vscode.
+
     The following fields for each cluster are recorded: cluster name, time
     since last launch, resources, region, zone, hourly price, status, autostop,
     command.
 
-    Display all fields using ``sky status -a``.
+    Display all fields using ``sky status -v``.
 
     Each cluster can have one of the following statuses:
 
@@ -1565,243 +1780,163 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
       or for autostop-enabled clusters, use ``--refresh`` to query the latest
       cluster statuses from the cloud providers.
     """
-    # Using a pool with 2 worker to run the managed job query and sky serve
-    # service query in parallel to speed up. The pool provides a AsyncResult
-    # object that can be used as a future.
-    with multiprocessing.Pool(2) as pool:
-        # Do not show job queue if user specifies clusters, and if user
-        # specifies --ip or --endpoint(s).
-        show_managed_jobs = show_managed_jobs and not any(
-            [clusters, ip, endpoints])
-        show_endpoints = endpoints or endpoint is not None
-        show_single_endpoint = endpoint is not None
-        if show_managed_jobs:
-            # Run managed job query in parallel to speed up the status query.
-            managed_jobs_future = pool.apply_async(
-                _get_managed_jobs,
-                kwds=dict(refresh=False,
-                          skip_finished=True,
-                          show_all=False,
-                          limit_num_jobs_to_show=not all,
-                          is_called_by_user=False))
-
-        show_services = show_services and not clusters and not ip
-        if show_services:
-            # Run the sky serve service query in parallel to speed up the
-            # status query.
-            services_future = pool.apply_async(_get_services,
-                                               kwds=dict(
-                                                   service_names=None,
-                                                   show_all=False,
-                                                   show_endpoint=False,
-                                                   is_called_by_user=False))
-        if ip or show_endpoints:
-            if refresh:
-                raise click.UsageError(
-                    'Using --ip or --endpoint(s) with --refresh is not'
-                    'supported for now. To fix, refresh first, '
-                    'then query the IP or endpoint.')
+    if kubernetes:
+        _status_kubernetes(verbose)
+        return
+    # Do not show job queue if user specifies clusters, and if user
+    # specifies --ip or --endpoint(s).
+    show_managed_jobs = show_managed_jobs and not any([clusters, ip, endpoints])
+    if show_managed_jobs:
+        managed_jobs_queue_request_id = managed_jobs.queue(refresh=False,
+                                                           skip_finished=True,
+                                                           all_users=all_users)
+    show_endpoints = endpoints or endpoint is not None
+    show_single_endpoint = endpoint is not None
+    show_services = show_services and not any([clusters, ip, endpoints])
+    if show_services:
+        # Run the sky serve service query in parallel to speed up the
+        # status query.
+        service_status_request_id = serve_lib.status(service_names=None)
+
+    if ip or show_endpoints:
+        if refresh:
+            raise click.UsageError(
+                'Using --ip or --endpoint(s) with --refresh is not'
+                'supported for now. To fix, refresh first, '
+                'then query the IP or endpoint.')
 
-            if ip and show_endpoints:
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError(
-                        'Cannot specify both --ip and --endpoint(s) '
-                        'at the same time.')
+        if ip and show_endpoints:
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError('Cannot specify both --ip and --endpoint(s) '
+                                 'at the same time.')
 
-            if endpoint is not None and endpoints:
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError(
-                        'Cannot specify both --endpoint and --endpoints '
-                        'at the same time.')
+        if endpoint is not None and endpoints:
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    'Cannot specify both --endpoint and --endpoints '
+                    'at the same time.')
 
-            if len(clusters) != 1:
-                with ux_utils.print_exception_no_traceback():
-                    plural = 's' if len(clusters) > 1 else ''
-                    cluster_num = (str(len(clusters))
-                                   if len(clusters) > 0 else 'No')
-                    cause = 'a single' if len(clusters) > 1 else 'an existing'
-                    raise ValueError(
-                        _STATUS_PROPERTY_CLUSTER_NUM_ERROR_MESSAGE.format(
-                            cluster_num=cluster_num,
-                            plural=plural,
-                            verb='specified',
-                            cause=cause,
-                            property='IP address' if ip else 'endpoint(s)',
-                            flag='ip' if ip else
-                            ('endpoint port'
-                             if show_single_endpoint else 'endpoints')))
+        if len(clusters) != 1:
+            with ux_utils.print_exception_no_traceback():
+                plural = 's' if len(clusters) > 1 else ''
+                cluster_num = (str(len(clusters)) if clusters else 'No')
+                cause = 'a single' if len(clusters) > 1 else 'an existing'
+                raise ValueError(
+                    _STATUS_PROPERTY_CLUSTER_NUM_ERROR_MESSAGE.format(
+                        cluster_num=cluster_num,
+                        plural=plural,
+                        verb='specified',
+                        cause=cause,
+                        property='IP address' if ip else 'endpoint(s)',
+                        flag='ip' if ip else
+                        ('endpoint port'
+                         if show_single_endpoint else 'endpoints')))
+    else:
+        click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}Clusters'
+                   f'{colorama.Style.RESET_ALL}')
+    query_clusters: Optional[List[str]] = None if not clusters else clusters
+    refresh_mode = common.StatusRefreshMode.NONE
+    if refresh:
+        refresh_mode = common.StatusRefreshMode.FORCE
+    cluster_records = _get_cluster_records_and_set_ssh_config(
+        query_clusters, refresh_mode, all_users)
+
+    # TOOD(zhwu): setup the ssh config for status
+    if ip or show_endpoints:
+        _show_endpoint(query_clusters, cluster_records, ip, endpoints, endpoint)
+        return
+    hints = []
+    normal_clusters = []
+    controllers = []
+    for cluster_record in cluster_records:
+        cluster_name = cluster_record['name']
+        controller = controller_utils.Controllers.from_name(cluster_name)
+        if controller is not None:
+            controllers.append(cluster_record)
         else:
-            click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}Clusters'
-                       f'{colorama.Style.RESET_ALL}')
-        query_clusters: Optional[List[str]] = None
-        if clusters:
-            query_clusters = _get_glob_clusters(clusters, silent=ip)
-        cluster_records = core.status(cluster_names=query_clusters,
-                                      refresh=refresh)
-        if ip or show_endpoints:
-            if len(cluster_records) != 1:
-                with ux_utils.print_exception_no_traceback():
-                    plural = 's' if len(cluster_records) > 1 else ''
-                    cluster_num = (str(len(cluster_records))
-                                   if len(cluster_records) > 0 else
-                                   f'{clusters[0]!r}')
-                    verb = 'found' if len(cluster_records) > 0 else 'not found'
-                    cause = 'a single' if len(clusters) > 1 else 'an existing'
-                    raise ValueError(
-                        _STATUS_PROPERTY_CLUSTER_NUM_ERROR_MESSAGE.format(
-                            cluster_num=cluster_num,
-                            plural=plural,
-                            verb=verb,
-                            cause=cause,
-                            property='IP address' if ip else 'endpoint(s)',
-                            flag='ip' if ip else
-                            ('endpoint port'
-                             if show_single_endpoint else 'endpoints')))
-
-            cluster_record = cluster_records[0]
-            if cluster_record['status'] != status_lib.ClusterStatus.UP:
-                with ux_utils.print_exception_no_traceback():
-                    raise RuntimeError(f'Cluster {cluster_record["name"]!r} '
-                                       'is not in UP status.')
-            handle = cluster_record['handle']
-            if not isinstance(handle, backends.CloudVmRayResourceHandle):
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError('Querying IP address is not supported '
-                                     'for local clusters.')
-
-            head_ip = handle.external_ips()[0]
-            if show_endpoints:
-                if endpoint:
-                    cluster_endpoint = core.endpoints(cluster_record['name'],
-                                                      endpoint).get(
-                                                          endpoint, None)
-                    if not cluster_endpoint:
-                        raise click.Abort(
-                            f'Endpoint {endpoint} not found for cluster '
-                            f'{cluster_record["name"]!r}.')
-                    click.echo(cluster_endpoint)
-                else:
-                    cluster_endpoints = core.endpoints(cluster_record['name'])
-                    assert isinstance(cluster_endpoints, dict)
-                    if not cluster_endpoints:
-                        raise click.Abort(f'No endpoint found for cluster '
-                                          f'{cluster_record["name"]!r}.')
-                    for port, port_endpoint in cluster_endpoints.items():
-                        click.echo(
-                            f'{colorama.Fore.BLUE}{colorama.Style.BRIGHT}{port}'
-                            f'{colorama.Style.RESET_ALL}: '
-                            f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
-                            f'{port_endpoint}{colorama.Style.RESET_ALL}')
-                return
-            click.echo(head_ip)
-            return
-        hints = []
-        normal_clusters = []
-        controllers = []
-        for cluster_record in cluster_records:
-            cluster_name = cluster_record['name']
-            controller = controller_utils.Controllers.from_name(cluster_name)
-            if controller is not None:
-                controllers.append(cluster_record)
-            else:
-                normal_clusters.append(cluster_record)
+            normal_clusters.append(cluster_record)
 
-        num_pending_autostop = 0
-        num_pending_autostop += status_utils.show_status_table(
-            normal_clusters + controllers, all)
+    num_pending_autostop = 0
+    num_pending_autostop += status_utils.show_status_table(
+        normal_clusters + controllers, verbose, all_users, query_clusters)
 
-        def _try_get_future_result(future) -> Tuple[bool, Any]:
-            result = None
-            interrupted = False
+    managed_jobs_query_interrupted = False
+    if show_managed_jobs:
+        click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                   f'Managed jobs{colorama.Style.RESET_ALL}')
+        with rich_utils.client_status('[cyan]Checking managed jobs[/]'):
             try:
-                result = future.get()
+                num_in_progress_jobs, msg = _handle_jobs_queue_request(
+                    managed_jobs_queue_request_id,
+                    show_all=False,
+                    show_user=False,
+                    limit_num_jobs_to_show=not all,
+                    is_called_by_user=False)
             except KeyboardInterrupt:
-                pool.terminate()
-                interrupted = True
-            return interrupted, result
-
-        managed_jobs_query_interrupted = False
-        if show_managed_jobs:
-            click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
-                       f'Managed jobs{colorama.Style.RESET_ALL}')
-            with rich_utils.safe_status('[cyan]Checking managed jobs[/]'):
-                managed_jobs_query_interrupted, result = _try_get_future_result(
-                    managed_jobs_future)
-                if managed_jobs_query_interrupted:
-                    # Set to -1, so that the controller is not considered
-                    # down, and the hint for showing sky jobs queue
-                    # will still be shown.
-                    num_in_progress_jobs = -1
-                    msg = 'KeyboardInterrupt'
-                else:
-                    num_in_progress_jobs, msg = result
-
-            click.echo(msg)
-            if num_in_progress_jobs is not None:
-                # jobs controller is UP.
-                job_info = ''
-                if num_in_progress_jobs > 0:
-                    plural_and_verb = ' is'
-                    if num_in_progress_jobs > 1:
-                        plural_and_verb = 's are'
-                    job_info = (
-                        f'{num_in_progress_jobs} managed job{plural_and_verb} '
-                        'in progress')
-                    if (num_in_progress_jobs >
-                            _NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS):
-                        job_info += (
-                            f' ({_NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS} latest '
-                            'ones shown)')
-                    job_info += '. '
-                hints.append(
-                    controller_utils.Controllers.JOBS_CONTROLLER.value.
-                    in_progress_hint.format(job_info=job_info))
-
-        if show_services:
-            click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
-                       f'Services{colorama.Style.RESET_ALL}')
-            num_services = None
-            if managed_jobs_query_interrupted:
-                # The pool is terminated, so we cannot run the service query.
+                sdk.api_cancel(managed_jobs_queue_request_id, silent=True)
+                managed_jobs_query_interrupted = True
+                # Set to -1, so that the controller is not considered
+                # down, and the hint for showing sky jobs queue
+                # will still be shown.
+                num_in_progress_jobs = -1
                 msg = 'KeyboardInterrupt'
-            else:
-                with rich_utils.safe_status('[cyan]Checking services[/]'):
-                    interrupted, result = _try_get_future_result(
-                        services_future)
-                    if interrupted:
-                        num_services = -1
-                        msg = 'KeyboardInterrupt'
-                    else:
-                        num_services, msg = result
-            click.echo(msg)
-            if num_services is not None:
-                hints.append(controller_utils.Controllers.SKY_SERVE_CONTROLLER.
-                             value.in_progress_hint)
 
-        if show_managed_jobs or show_services:
-            try:
-                pool.close()
-                pool.join()
-            except SystemExit as e:
-                # This is to avoid a "Exception ignored" problem caused by
-                # ray worker setting the sigterm handler to sys.exit(15)
-                # (see ray/_private/worker.py).
-                # TODO (zhwu): Remove any importing of ray in SkyPilot.
-                if e.code != 15:
-                    raise
-
-        if num_pending_autostop > 0 and not refresh:
-            # Don't print this hint if there's no pending autostop or user has
-            # already passed --refresh.
-            plural_and_verb = ' has'
-            if num_pending_autostop > 1:
-                plural_and_verb = 's have'
-            hints.append(f'* {num_pending_autostop} cluster{plural_and_verb} '
-                         'auto{stop,down} scheduled. Refresh statuses with: '
-                         f'{colorama.Style.BRIGHT}sky status --refresh'
-                         f'{colorama.Style.RESET_ALL}')
-        if hints:
-            click.echo('\n' + '\n'.join(hints))
+        click.echo(msg)
+        if num_in_progress_jobs is not None:
+            # jobs controller is UP.
+            job_info = ''
+            if num_in_progress_jobs > 0:
+                plural_and_verb = ' is'
+                if num_in_progress_jobs > 1:
+                    plural_and_verb = 's are'
+                job_info = (
+                    f'{num_in_progress_jobs} managed job{plural_and_verb} '
+                    'in progress')
+                if num_in_progress_jobs > _NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS:
+                    job_info += (
+                        f' ({_NUM_MANAGED_JOBS_TO_SHOW_IN_STATUS} latest '
+                        'ones shown)')
+                job_info += '. '
+            hints.append(
+                controller_utils.Controllers.JOBS_CONTROLLER.value.
+                in_progress_hint.format(job_info=job_info))
+
+    if show_services:
+        click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                   f'Services{colorama.Style.RESET_ALL}')
+        num_services = None
+        if managed_jobs_query_interrupted:
+            msg = 'KeyboardInterrupt'
+        else:
+            with rich_utils.client_status('[cyan]Checking services[/]'):
+                try:
+                    num_services, msg = _handle_services_request(
+                        service_status_request_id,
+                        service_names=None,
+                        show_all=False,
+                        show_endpoint=False,
+                        is_called_by_user=False)
+                except KeyboardInterrupt:
+                    sdk.api_cancel(service_status_request_id, silent=True)
+                    num_services = -1
+                    msg = 'KeyboardInterrupt'
+        click.echo(msg)
+        if num_services is not None:
+            hints.append(controller_utils.Controllers.SKY_SERVE_CONTROLLER.
+                         value.in_progress_hint)
+
+    if num_pending_autostop > 0 and not refresh:
+        # Don't print this hint if there's no pending autostop or user has
+        # already passed --refresh.
+        plural_and_verb = ' has'
+        if num_pending_autostop > 1:
+            plural_and_verb = 's have'
+        hints.append(f'* {num_pending_autostop} cluster{plural_and_verb} '
+                     'auto{stop,down} scheduled. Refresh statuses with: '
+                     f'{colorama.Style.BRIGHT}sky status --refresh'
+                     f'{colorama.Style.RESET_ALL}')
+    if hints:
+        click.echo('\n' + '\n'.join(hints))
 
 
 @cli.command()
@@ -1810,7 +1945,7 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
               default=False,
               is_flag=True,
               required=False,
-              help='Show all information in full.')
+              help='Show all cluster information.')
 @usage_lib.entrypoint
 def cost_report(all: bool):  # pylint: disable=redefined-builtin
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
@@ -1831,7 +1966,7 @@ def cost_report(all: bool):  # pylint: disable=redefined-builtin
 
     - Clusters that were terminated/stopped on the cloud console.
     """
-    cluster_records = core.cost_report()
+    cluster_records = sdk.get(sdk.cost_report())
 
     normal_cluster_records = []
     controllers = dict()
@@ -1876,7 +2011,7 @@ def cost_report(all: bool):  # pylint: disable=redefined-builtin
 
 @cli.command()
 @click.option('--all-users',
-              '-a',
+              '-u',
               default=False,
               is_flag=True,
               required=False,
@@ -1896,18 +2031,21 @@ def cost_report(all: bool):  # pylint: disable=redefined-builtin
 def queue(clusters: List[str], skip_finished: bool, all_users: bool):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Show the job queue for cluster(s)."""
-    click.secho('Fetching and parsing job queue...', fg='yellow')
-    if clusters:
-        clusters = _get_glob_clusters(clusters)
-    else:
-        cluster_infos = global_user_state.get_clusters()
-        clusters = [c['name'] for c in cluster_infos]
+    click.secho('Fetching and parsing job queue...', fg='cyan')
+    if not clusters:
+        cluster_records = _get_cluster_records_and_set_ssh_config(
+            None, all_users=all_users)
+        clusters = [cluster['name'] for cluster in cluster_records]
 
     unsupported_clusters = []
-    for cluster in clusters:
+    logger.info(f'Fetching job queue for: {", ".join(clusters)}')
+    job_tables = {}
+
+    def _get_job_queue(cluster):
         try:
-            job_table = core.queue(cluster, skip_finished, all_users)
-        except (exceptions.CommandError, ValueError,
+            job_table = sdk.stream_and_get(
+                sdk.queue(cluster, skip_finished, all_users))
+        except (RuntimeError, exceptions.CommandError, ValueError,
                 exceptions.NotSupportedError, exceptions.ClusterNotUpError,
                 exceptions.CloudUserIdentityError,
                 exceptions.ClusterOwnerIdentityMismatchError) as e:
@@ -1916,9 +2054,14 @@ def queue(clusters: List[str], skip_finished: bool, all_users: bool):
             click.echo(f'{colorama.Fore.YELLOW}Failed to get the job queue for '
                        f'cluster {cluster!r}.{colorama.Style.RESET_ALL}\n'
                        f'  {common_utils.format_exception(e)}')
-            continue
-        job_table = job_lib.format_job_queue(job_table)
-        click.echo(f'\nJob queue of cluster {cluster}\n{job_table}')
+            return
+        job_tables[cluster] = job_lib.format_job_queue(job_table)
+
+    subprocess_utils.run_in_parallel(_get_job_queue, clusters)
+    user_str = 'all users' if all_users else 'current user'
+    for cluster, job_table in job_tables.items():
+        click.echo(f'\nJob queue of {user_str} on cluster {cluster}\n'
+                   f'{job_table}')
 
     if unsupported_clusters:
         click.secho(
@@ -1948,6 +2091,12 @@ def queue(clusters: List[str], skip_finished: bool, all_users: bool):
     help=('Follow the logs of a job. '
           'If --no-follow is specified, print the log so far and exit. '
           '[default: --follow]'))
+@click.option(
+    '--tail',
+    default=0,
+    type=int,
+    help=('The number of lines to display from the end of the log file. '
+          'Default is 0, which means print all lines.'))
 @click.argument('cluster',
                 required=True,
                 type=str,
@@ -1961,6 +2110,7 @@ def logs(
     sync_down: bool,
     status: bool,  # pylint: disable=redefined-outer-name
     follow: bool,
+    tail: int,
 ):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Tail the log of a job.
@@ -1991,25 +2141,34 @@ def logs(
     job_ids = None if not job_ids else job_ids
 
     if sync_down:
-        core.download_logs(cluster, job_ids)
+        with rich_utils.client_status(
+                ux_utils.spinner_message('Downloading logs')):
+            log_local_path_dict = sdk.download_logs(cluster, job_ids)
+        style = colorama.Style
+        fore = colorama.Fore
+        for job, log_local_path in log_local_path_dict.items():
+            logger.info(f'{fore.CYAN}Job {job} logs: {log_local_path}'
+                        f'{style.RESET_ALL}')
         return
 
     assert job_ids is None or len(job_ids) <= 1, job_ids
-    job_id = None
+    job_id: Optional[int] = None
     job_ids_to_query: Optional[List[int]] = None
     if job_ids:
         # Already check that len(job_ids) <= 1. This variable is used later
-        # in core.tail_logs.
-        job_id = job_ids[0]
-        if not job_id.isdigit():
-            raise click.UsageError(f'Invalid job ID {job_id}. '
+        # in sdk.tail_logs.
+        cur_job_id = job_ids[0]
+        if not cur_job_id.isdigit():
+            raise click.UsageError(f'Invalid job ID {cur_job_id}. '
                                    'Job ID must be integers.')
-        job_ids_to_query = [int(job_id)]
+        job_id = int(cur_job_id)
+        job_ids_to_query = [int(job_ids[0])]
     else:
         # job_ids is either None or empty list, so it is safe to cast it here.
         job_ids_to_query = typing.cast(Optional[List[int]], job_ids)
     if status:
-        job_statuses = core.job_status(cluster, job_ids_to_query)
+        job_statuses = sdk.stream_and_get(
+            sdk.job_status(cluster, job_ids_to_query))
         job_id = list(job_statuses.keys())[0]
         # If job_ids is None and no job has been submitted to the cluster,
         # it will return {None: None}.
@@ -2027,7 +2186,15 @@ def logs(
                 click.secho(f'Job {id_str}not found', fg='red')
             sys.exit(1)
 
-    core.tail_logs(cluster, job_id, follow)
+    job_str = f'job {job_id}'
+    if job_id is None:
+        job_str = 'the last job'
+    logger.info(f'{colorama.Fore.YELLOW}'
+                f'Tailing logs of {job_str} on cluster {cluster!r}...'
+                f'{colorama.Style.RESET_ALL}')
+
+    # Stream logs from the server.
+    sdk.tail_logs(cluster, job_id, follow, tail=tail)
 
 
 @cli.command()
@@ -2040,16 +2207,31 @@ def logs(
               default=False,
               is_flag=True,
               required=False,
-              help='Cancel all jobs on the specified cluster.')
+              help='Cancel all jobs from current user on the specified cluster.'
+             )
+@click.option('--all-users',
+              '-u',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Cancel all jobs on the specified cluster for all users.')
 @click.option('--yes',
               '-y',
               is_flag=True,
               default=False,
               required=False,
               help='Skip confirmation prompt.')
+@_add_click_options(_COMMON_OPTIONS)
 @click.argument('jobs', required=False, type=int, nargs=-1)
 @usage_lib.entrypoint
-def cancel(cluster: str, all: bool, jobs: List[int], yes: bool):  # pylint: disable=redefined-builtin, redefined-outer-name
+def cancel(
+    cluster: str,
+    all: bool,  # pylint: disable=redefined-builtin
+    all_users: bool,
+    jobs: List[int],  # pylint: disable=redefined-outer-name
+    yes: bool,
+    async_call: bool,
+):  # pylint: disable=redefined-builtin
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Cancel job(s).
 
@@ -2062,30 +2244,36 @@ def cancel(cluster: str, all: bool, jobs: List[int], yes: bool):  # pylint: disa
       sky cancel cluster_name 1
       sky cancel cluster_name 1 2 3
       \b
-      # Cancel all jobs on a cluster.
+      # Cancel all your jobs on a cluster.
       sky cancel cluster_name -a
       \b
+      # Cancel all users' jobs on a cluster.
+      sky cancel cluster_name -u
+      \b
       # Cancel the latest running job on a cluster.
       sky cancel cluster_name
 
     Job IDs can be looked up by ``sky queue cluster_name``.
     """
-    job_identity_str = None
+    job_identity_str = ''
     job_ids_to_cancel = None
-    if not jobs and not all:
-        click.echo(f'{colorama.Fore.YELLOW}No job IDs or --all provided; '
-                   'cancelling the latest running job.'
-                   f'{colorama.Style.RESET_ALL}')
+    if not jobs and not all and not all_users:
+        click.echo(
+            f'{colorama.Fore.YELLOW}No job IDs or --all/--all-users provided; '
+            'cancelling the latest running job.'
+            f'{colorama.Style.RESET_ALL}')
         job_identity_str = 'the latest running job'
+    elif all_users:
+        job_identity_str = 'all users\' jobs'
     else:
-        # Cancelling specific jobs or --all.
-        job_ids = ' '.join(map(str, jobs))
-        plural = 's' if len(job_ids) > 1 else ''
-        job_identity_str = f'job{plural} {job_ids}'
-        job_ids_to_cancel = jobs
         if all:
-            job_identity_str = 'all jobs'
-            job_ids_to_cancel = None
+            job_identity_str = 'all your jobs'
+        if jobs:
+            jobs_str = ' '.join(map(str, jobs))
+            plural = 's' if len(jobs) > 1 else ''
+            connector = ' and ' if job_identity_str else ''
+            job_identity_str += f'{connector}job{plural} {jobs_str}'
+            job_ids_to_cancel = jobs
     job_identity_str += f' on cluster {cluster!r}'
 
     if not yes:
@@ -2095,7 +2283,11 @@ def cancel(cluster: str, all: bool, jobs: List[int], yes: bool):  # pylint: disa
                       show_default=True)
 
     try:
-        core.cancel(cluster, all=all, job_ids=job_ids_to_cancel)
+        request_id = sdk.cancel(cluster,
+                                all=all,
+                                all_users=all_users,
+                                job_ids=job_ids_to_cancel)
+        _async_call_or_wait(request_id, async_call, 'sky.cancel')
     except exceptions.NotSupportedError as e:
         controller = controller_utils.Controllers.from_name(cluster)
         assert controller is not None, cluster
@@ -2115,20 +2307,28 @@ def cancel(cluster: str, all: bool, jobs: List[int], yes: bool):  # pylint: disa
                 **_get_shell_complete_args(_complete_cluster_name))
 @click.option('--all',
               '-a',
-              default=None,
+              default=False,
               is_flag=True,
               help='Stop all existing clusters.')
+@click.option('--all-users',
+              '-u',
+              default=False,
+              is_flag=True,
+              help='Stop all existing clusters for all users.')
 @click.option('--yes',
               '-y',
               is_flag=True,
               default=False,
               required=False,
               help='Skip confirmation prompt.')
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
 def stop(
     clusters: List[str],
-    all: Optional[bool],  # pylint: disable=redefined-builtin
+    all: bool,  # pylint: disable=redefined-builtin
+    all_users: bool,
     yes: bool,
+    async_call: bool,
 ):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Stop cluster(s).
@@ -2161,8 +2361,10 @@ def stop(
     """
     _down_or_stop_clusters(clusters,
                            apply_to_all=all,
+                           all_users=all_users,
                            down=False,
-                           no_confirm=yes)
+                           no_confirm=yes,
+                           async_call=async_call)
 
 
 @cli.command(cls=_DocumentedCodeCommand)
@@ -2172,9 +2374,14 @@ def stop(
                 **_get_shell_complete_args(_complete_cluster_name))
 @click.option('--all',
               '-a',
-              default=None,
+              default=False,
+              is_flag=True,
+              help='Autostop all existing clusters.')
+@click.option('--all-users',
+              '-u',
+              default=False,
               is_flag=True,
-              help='Apply this command to all existing clusters.')
+              help='Autostop all existing clusters for all users.')
 @click.option('--idle-minutes',
               '-i',
               type=int,
@@ -2202,14 +2409,17 @@ def stop(
               default=False,
               required=False,
               help='Skip confirmation prompt.')
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
 def autostop(
     clusters: List[str],
-    all: Optional[bool],  # pylint: disable=redefined-builtin
+    all: bool,  # pylint: disable=redefined-builtin
+    all_users: bool,
     idle_minutes: Optional[int],
     cancel: bool,  # pylint: disable=redefined-outer-name
     down: bool,  # pylint: disable=redefined-outer-name
     yes: bool,
+    async_call: bool,
 ):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Schedule an autostop or autodown for cluster(s).
@@ -2262,9 +2472,11 @@ def autostop(
         idle_minutes = 5
     _down_or_stop_clusters(clusters,
                            apply_to_all=all,
+                           all_users=all_users,
                            down=down,
                            no_confirm=yes,
-                           idle_minutes_to_autostop=idle_minutes)
+                           idle_minutes_to_autostop=idle_minutes,
+                           async_call=async_call)
 
 
 @cli.command(cls=_DocumentedCodeCommand)
@@ -2327,16 +2539,19 @@ def autostop(
     required=False,
     help=('Force start the cluster even if it is already UP. Useful for '
           'upgrading the SkyPilot runtime on the cluster.'))
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
 def start(
-        clusters: List[str],
-        all: bool,
-        yes: bool,
-        idle_minutes_to_autostop: Optional[int],
-        down: bool,  # pylint: disable=redefined-outer-name
-        retry_until_up: bool,
-        force: bool):
+    clusters: List[str],
+    all: bool,
+    yes: bool,
+    idle_minutes_to_autostop: Optional[int],
+    down: bool,  # pylint: disable=redefined-outer-name
+    retry_until_up: bool,
+    force: bool,
+    async_call: bool,
+):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Restart cluster(s).
 
@@ -2370,40 +2585,45 @@ def start(
             '--idle-minutes-to-autostop must be set if --down is set.')
     to_start = []
 
+    cluster_records = None
     if not clusters and not all:
         # UX: frequently users may have only 1 cluster. In this case, be smart
         # and default to that unique choice.
-        all_cluster_names = global_user_state.get_cluster_names_start_with('')
-        if len(all_cluster_names) <= 1:
-            clusters = all_cluster_names
+        all_clusters = _get_cluster_records_and_set_ssh_config(
+            clusters=None, refresh=common.StatusRefreshMode.AUTO)
+        if len(all_clusters) <= 1:
+            cluster_records = all_clusters
         else:
             raise click.UsageError(
                 '`sky start` requires either a cluster name or glob '
                 '(see `sky status`), or the -a/--all flag.')
 
     if all:
-        if len(clusters) > 0:
+        if clusters:
             click.echo('Both --all and cluster(s) specified for sky start. '
                        'Letting --all take effect.')
 
+        all_clusters = _get_cluster_records_and_set_ssh_config(
+            clusters=None, refresh=common.StatusRefreshMode.AUTO)
+
         # Get all clusters that are not controllers.
-        clusters = [
-            cluster['name']
-            for cluster in global_user_state.get_clusters()
+        cluster_records = [
+            cluster for cluster in all_clusters
             if controller_utils.Controllers.from_name(cluster['name']) is None
         ]
+    if cluster_records is None:
+        # Get GLOB cluster names
+        cluster_records = _get_cluster_records_and_set_ssh_config(
+            clusters, refresh=common.StatusRefreshMode.AUTO)
 
-    if not clusters:
+    if not cluster_records:
         click.echo('Cluster(s) not found (tip: see `sky status`). Do you '
                    'mean to use `sky launch` to provision a new cluster?')
         return
     else:
-        # Get GLOB cluster names
-        clusters = _get_glob_clusters(clusters)
-
-        for name in clusters:
-            cluster_status, _ = backend_utils.refresh_cluster_status_handle(
-                name)
+        for cluster in cluster_records:
+            name = cluster['name']
+            cluster_status = cluster['status']
             # A cluster may have one of the following states:
             #
             #  STOPPED - ok to restart
@@ -2461,8 +2681,8 @@ def start(
                                'is currently not supported.\n'
                                'Please start the former independently.')
     if controllers:
-        bold = backend_utils.BOLD
-        reset_bold = backend_utils.RESET_BOLD
+        bold = ux_utils.BOLD
+        reset_bold = ux_utils.RESET_BOLD
         if len(controllers) != 1:
             raise click.UsageError(
                 'Starting multiple controllers is currently not supported.\n'
@@ -2483,18 +2703,25 @@ def start(
             abort=True,
             show_default=True)
 
-    for name in to_start:
+    request_ids = subprocess_utils.run_in_parallel(
+        lambda name: sdk.start(name,
+                               idle_minutes_to_autostop,
+                               retry_until_up,
+                               down=down,
+                               force=force), to_start)
+
+    for name, request_id in zip(to_start, request_ids):
         try:
-            core.start(name,
-                       idle_minutes_to_autostop,
-                       retry_until_up,
-                       down=down,
-                       force=force)
+            _async_call_or_wait(request_id, async_call, 'sky.start')
+            if not async_call:
+                # Add ssh config for the cluster
+                _get_cluster_records_and_set_ssh_config(clusters=[name])
         except (exceptions.NotSupportedError,
                 exceptions.ClusterOwnerIdentityMismatchError) as e:
             click.echo(str(e))
         else:
-            click.secho(f'Cluster {name} started.', fg='green')
+            if not async_call:
+                click.secho(f'Cluster {name} started.', fg='green')
 
 
 @cli.command(cls=_DocumentedCodeCommand)
@@ -2504,10 +2731,15 @@ def start(
                 **_get_shell_complete_args(_complete_cluster_name))
 @click.option('--all',
               '-a',
-              default=None,
+              default=False,
               is_flag=True,
               help='Tear down all existing clusters.')
-@click.option('--yes',
+@click.option('--all-users',
+              '-u',
+              default=False,
+              is_flag=True,
+              help='Tear down all existing clusters for all users.')
+@click.option('--yes',
               '-y',
               is_flag=True,
               default=False,
@@ -2525,12 +2757,15 @@ def start(
           ' in certain manual troubleshooting scenarios; with it set, it is the'
           ' user\'s responsibility to ensure there are no leaked instances and '
           'related resources.'))
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
 def down(
     clusters: List[str],
-    all: Optional[bool],  # pylint: disable=redefined-builtin
+    all: bool,  # pylint: disable=redefined-builtin
+    all_users: bool,
     yes: bool,
     purge: bool,
+    async_call: bool,
 ):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Tear down cluster(s).
@@ -2562,12 +2797,15 @@ def down(
     """
     _down_or_stop_clusters(clusters,
                            apply_to_all=all,
+                           all_users=all_users,
                            down=True,
                            no_confirm=yes,
-                           purge=purge)
+                           purge=purge,
+                           async_call=async_call)
 
 
-def _hint_or_raise_for_down_jobs_controller(controller_name: str):
+def _hint_or_raise_for_down_jobs_controller(controller_name: str,
+                                            purge: bool) -> None:
     """Helper function to check job controller status before tearing it down.
 
     Raises helpful exceptions and errors if the controller is not in a safe
@@ -2582,11 +2820,13 @@ def _hint_or_raise_for_down_jobs_controller(controller_name: str):
     controller = controller_utils.Controllers.from_name(controller_name)
     assert controller is not None, controller_name
 
-    with rich_utils.safe_status(
+    with rich_utils.client_status(
             '[bold cyan]Checking for in-progress managed jobs[/]'):
         try:
-            managed_jobs_ = managed_jobs.queue(refresh=False,
-                                               skip_finished=True)
+            request_id = managed_jobs.queue(refresh=False,
+                                            skip_finished=True,
+                                            all_users=True)
+            managed_jobs_ = sdk.stream_and_get(request_id)
         except exceptions.ClusterNotUpError as e:
             if controller.value.connection_error_hint in str(e):
                 with ux_utils.print_exception_no_traceback():
@@ -2609,19 +2849,26 @@ def _hint_or_raise_for_down_jobs_controller(controller_name: str):
            'jobs (output of `sky jobs queue`) will be lost.')
     click.echo(msg)
     if managed_jobs_:
-        job_table = managed_jobs.format_job_table(managed_jobs_, show_all=False)
+        job_table = managed_jobs.format_job_table(managed_jobs_,
+                                                  show_all=False,
+                                                  show_user=True)
         msg = controller.value.decline_down_for_dirty_controller_hint
         # Add prefix to each line to align with the bullet point.
         msg += '\n'.join(
             ['   ' + line for line in job_table.split('\n') if line != ''])
-        with ux_utils.print_exception_no_traceback():
-            raise exceptions.NotSupportedError(msg)
+        if purge:
+            logger.warning('--purge is set, ignoring the in-progress managed '
+                           'jobs. This could cause leaked clusters!')
+        else:
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.NotSupportedError(msg)
     else:
         click.echo(' * No in-progress managed jobs found. It should be safe to '
                    'terminate (see caveats above).')
 
 
-def _hint_or_raise_for_down_sky_serve_controller(controller_name: str):
+def _hint_or_raise_for_down_sky_serve_controller(controller_name: str,
+                                                 purge: bool) -> None:
     """Helper function to check serve controller status before tearing it down.
 
     Raises helpful exceptions and errors if the controller is not in a safe
@@ -2635,9 +2882,10 @@ def _hint_or_raise_for_down_sky_serve_controller(controller_name: str):
     """
     controller = controller_utils.Controllers.from_name(controller_name)
     assert controller is not None, controller_name
-    with rich_utils.safe_status('[bold cyan]Checking for live services[/]'):
+    with rich_utils.client_status('[bold cyan]Checking for live services[/]'):
         try:
-            services = serve_lib.status()
+            request_id = serve_lib.status(service_names=None)
+            services = sdk.stream_and_get(request_id)
         except exceptions.ClusterNotUpError as e:
             if controller.value.connection_error_hint in str(e):
                 with ux_utils.print_exception_no_traceback():
@@ -2654,35 +2902,52 @@ def _hint_or_raise_for_down_sky_serve_controller(controller_name: str):
 
     if services:
         service_names = [service['name'] for service in services]
-        with ux_utils.print_exception_no_traceback():
-            msg = (
-                controller.value.decline_down_for_dirty_controller_hint.format(
-                    service_names=', '.join(service_names)))
-            raise exceptions.NotSupportedError(msg)
+        if purge:
+            logger.warning('--purge is set, ignoring the in-progress services. '
+                           'This could cause leaked clusters!')
+        else:
+            with ux_utils.print_exception_no_traceback():
+                msg = (controller.value.decline_down_for_dirty_controller_hint.
+                       format(service_names=', '.join(service_names)))
+                raise exceptions.NotSupportedError(msg)
     # Do nothing for STOPPED state, as it is safe to terminate the cluster.
     click.echo(f'Terminate sky serve controller: {controller_name}.')
 
 
-_CONTROLLER_TO_HINT_OR_RAISE = {
-    controller_utils.Controllers.JOBS_CONTROLLER:
-        (_hint_or_raise_for_down_jobs_controller),
-    controller_utils.Controllers.SKY_SERVE_CONTROLLER:
-        (_hint_or_raise_for_down_sky_serve_controller),
-}
+def _controller_to_hint_or_raise(
+        controller: controller_utils.Controllers
+) -> Callable[[str, bool], None]:
+    if controller == controller_utils.Controllers.JOBS_CONTROLLER:
+        return _hint_or_raise_for_down_jobs_controller
+    return _hint_or_raise_for_down_sky_serve_controller
 
 
 def _down_or_stop_clusters(
         names: List[str],
-        apply_to_all: Optional[bool],
-        down: bool,  # pylint: disable=redefined-outer-name
-        no_confirm: bool,
+        apply_to_all: bool = False,
+        all_users: bool = False,
+        down: bool = False,  # pylint: disable=redefined-outer-name
+        no_confirm: bool = True,
         purge: bool = False,
-        idle_minutes_to_autostop: Optional[int] = None) -> None:
+        idle_minutes_to_autostop: Optional[int] = None,
+        async_call: bool = False) -> None:
     """Tears down or (auto-)stops a cluster (or all clusters).
 
     Controllers (jobs controller and sky serve controller) can only be
     terminated if the cluster name is explicitly and uniquely specified (not
     via glob).
+
+    Args:
+        names: The names of the clusters to tear down or stop. If empty,
+            apply_to_all or all_users must be set.
+        apply_to_all: If True, apply the operation to all clusters.
+        all_users: If True, apply the operation to all clusters for all users.
+        down: If True, tear down the clusters.
+        no_confirm: If True, skip the confirmation prompt.
+        purge: If True, forcefully remove the clusters from the cluster table.
+        idle_minutes_to_autostop: The number of minutes to wait before
+            automatically stopping the cluster.
+        async_call: If True, send the request asynchronously.
     """
     if down:
         command = 'down'
@@ -2690,17 +2955,12 @@ def _down_or_stop_clusters(
         command = 'autostop'
     else:
         command = 'stop'
-    if not names and apply_to_all is None:
-        # UX: frequently users may have only 1 cluster. In this case, 'sky
-        # stop/down' without args should be smart and default to that unique
-        # choice.
-        all_cluster_names = global_user_state.get_cluster_names_start_with('')
-        if len(all_cluster_names) <= 1:
-            names = all_cluster_names
-        else:
-            raise click.UsageError(
-                f'`sky {command}` requires either a cluster name or glob '
-                '(see `sky status`), or the -a/--all flag.')
+    if not names and not apply_to_all and not all_users:
+        raise click.UsageError(
+            f'`sky {command}` requires either a cluster name or glob '
+            '(see `sky status`), or the -a/--all flag for all your '
+            'clusters, or the -u/--all-users flag for all clusters in '
+            'your team.')
 
     operation = 'Terminating' if down else 'Stopping'
     if idle_minutes_to_autostop is not None:
@@ -2711,21 +2971,23 @@ def _down_or_stop_clusters(
             option_str = '{stop,down}'
         operation = f'{verb} auto{option_str} on'
 
-    if len(names) > 0:
+    names = list(names)
+    if names:
         controllers = [
             name for name in names
             if controller_utils.Controllers.from_name(name) is not None
         ]
         controllers_str = ', '.join(map(repr, controllers))
         names = [
-            name for name in _get_glob_clusters(names)
-            if controller_utils.Controllers.from_name(name) is None
+            cluster['name']
+            for cluster in _get_cluster_records_and_set_ssh_config(names)
+            if controller_utils.Controllers.from_name(cluster['name']) is None
         ]
 
         # Make sure the controllers are explicitly specified without other
         # normal clusters.
         if controllers:
-            if len(names) != 0:
+            if names:
                 names_str = ', '.join(map(repr, names))
                 raise click.UsageError(
                     f'{operation} controller(s) '
@@ -2746,7 +3008,7 @@ def _down_or_stop_clusters(
                 controller = controller_utils.Controllers.from_name(
                     controller_name)
                 assert controller is not None
-                hint_or_raise = _CONTROLLER_TO_HINT_OR_RAISE[controller]
+                hint_or_raise = _controller_to_hint_or_raise(controller)
                 try:
                     # TODO(zhwu): This hint or raise is not transactional, which
                     # means even if it passed the check with no in-progress spot
@@ -2755,7 +3017,7 @@ def _down_or_stop_clusters(
                     # `sky serve up` before typing the delete, causing a leaked
                     # managed job or service. We should make this check atomic
                     # with the termination.
-                    hint_or_raise(controller_name)
+                    hint_or_raise(controller_name, purge)
                 except (exceptions.ClusterOwnerIdentityMismatchError,
                         RuntimeError) as e:
                     if purge:
@@ -2776,9 +3038,10 @@ def _down_or_stop_clusters(
                 no_confirm = True
         names += controllers
 
-    if apply_to_all:
-        all_clusters = global_user_state.get_clusters()
-        if len(names) > 0:
+    if apply_to_all or all_users:
+        all_clusters = _get_cluster_records_and_set_ssh_config(
+            clusters=None, all_users=all_users)
+        if names:
             click.echo(
                 f'Both --all and cluster(s) specified for `sky {command}`. '
                 'Letting --all take effect.')
@@ -2790,22 +3053,14 @@ def _down_or_stop_clusters(
             if controller_utils.Controllers.from_name(record['name']) is None
         ]
 
-    clusters = []
-    for name in names:
-        handle = global_user_state.get_handle_from_cluster_name(name)
-        if handle is None:
-            # This codepath is used for 'sky down -p <controller>' when the
-            # controller is not in 'sky status'.  Cluster-not-found message
-            # should've been printed by _get_glob_clusters() above.
-            continue
-        clusters.append(name)
+    clusters = names
     usage_lib.record_cluster_name_for_current_operation(clusters)
 
     if not clusters:
         click.echo('Cluster(s) not found (tip: see `sky status`).')
         return
 
-    if not no_confirm and len(clusters) > 0:
+    if not no_confirm and clusters:
         cluster_str = 'clusters' if len(clusters) > 1 else 'cluster'
         cluster_list = ', '.join(clusters)
         click.confirm(
@@ -2823,11 +3078,17 @@ def _down_or_stop_clusters(
         f'[bold cyan]{operation} {len(clusters)} cluster{plural}[/]',
         total=len(clusters))
 
+    request_ids = []
+
     def _down_or_stop(name: str):
         success_progress = False
         if idle_minutes_to_autostop is not None:
             try:
-                core.autostop(name, idle_minutes_to_autostop, down)
+                request_id = sdk.autostop(name, idle_minutes_to_autostop, down)
+                request_ids.append(request_id)
+                _async_call_or_wait(
+                    request_id, async_call,
+                    server_constants.REQUEST_NAME_PREFIX + operation)
             except (exceptions.NotSupportedError,
                     exceptions.ClusterNotUpError) as e:
                 message = str(e)
@@ -2850,9 +3111,17 @@ def _down_or_stop_clusters(
         else:
             try:
                 if down:
-                    core.down(name, purge=purge)
+                    request_id = sdk.down(name, purge=purge)
                 else:
-                    core.stop(name, purge=purge)
+                    request_id = sdk.stop(name, purge=purge)
+                request_ids.append(request_id)
+                _async_call_or_wait(
+                    request_id, async_call,
+                    server_constants.REQUEST_NAME_PREFIX + operation)
+                if not async_call:
+                    # Remove the cluster from the SSH config file as soon as it
+                    # is stopped or downed.
+                    cluster_utils.SSHConfigHelper.remove_cluster(name)
             except RuntimeError as e:
                 message = (
                     f'{colorama.Fore.RED}{operation} cluster {name}...failed. '
@@ -2883,6 +3152,10 @@ def _down_or_stop_clusters(
         # Make sure the progress bar not mess up the terminal.
         progress.refresh()
 
+    if async_call:
+        click.secho(f'{operation} requests are sent. Check the requests\' '
+                    'status with `sky request get <request_id>`.')
+
 
 @cli.command(cls=_DocumentedCodeCommand)
 @click.argument('clouds', required=False, type=str, nargs=-1)
@@ -2892,6 +3165,7 @@ def _down_or_stop_clusters(
               default=False,
               help='Show the activated account for each cloud.')
 @usage_lib.entrypoint
+# pylint: disable=redefined-outer-name
 def check(clouds: Tuple[str], verbose: bool):
     """Check which clouds are available to use.
 
@@ -2915,7 +3189,12 @@ def check(clouds: Tuple[str], verbose: bool):
       sky check aws gcp
     """
     clouds_arg = clouds if len(clouds) > 0 else None
-    sky_check.check(verbose=verbose, clouds=clouds_arg)
+    request_id = sdk.check(clouds=clouds_arg, verbose=verbose)
+    sdk.stream_and_get(request_id)
+    api_server_url = server_common.get_server_url()
+    click.echo()
+    click.echo(
+        click.style(f'Using SkyPilot API server: {api_server_url}', fg='green'))
 
 
 @cli.command()
@@ -2972,9 +3251,9 @@ def show_gpus(
     and spot instances. There may be multiple regions with the same lowest
     price.
 
-    If ``--cloud kubernetes`` is specified, it will show the maximum quantities
-    of the GPU available on a single node and the real-time availability of
-    the GPU across all nodes in the Kubernetes cluster.
+    If ``--cloud kubernetes`` or ``--cloud k8s`` is specified, it will show the
+    maximum quantities of the GPU available on a single node and the real-time
+    availability of the GPU across all nodes in the Kubernetes cluster.
 
     Definitions of certain fields:
 
@@ -3008,49 +3287,45 @@ def show_gpus(
             '--all-regions and --region flags cannot be used simultaneously.')
 
     # This will validate 'cloud' and raise if not found.
-    cloud_obj = sky_clouds.CLOUD_REGISTRY.from_str(cloud)
-    service_catalog.validate_region_zone(region, None, clouds=cloud)
+    cloud_obj = registry.CLOUD_REGISTRY.from_str(cloud)
+    cloud_name = str(cloud_obj).lower() if cloud is not None else None
     show_all = all
     if show_all and accelerator_str is not None:
         raise click.UsageError('--all is only allowed without a GPU name.')
 
     # Kubernetes specific bools
-    cloud_is_kubernetes = isinstance(cloud_obj, sky_clouds.Kubernetes)
+    enabled_clouds = sdk.get(sdk.enabled_clouds())
+    cloud_is_kubernetes = isinstance(cloud_obj, clouds.Kubernetes)
+    # TODO(romilb): We should move this to the backend.
     kubernetes_autoscaling = kubernetes_utils.get_autoscaler_type() is not None
-    kubernetes_is_enabled = sky_clouds.cloud_in_iterable(
-        sky_clouds.Kubernetes(), global_user_state.get_cached_enabled_clouds())
-
-    if cloud_is_kubernetes and region is not None:
-        raise click.UsageError(
-            'The --region flag cannot be set with --cloud kubernetes.')
+    kubernetes_is_enabled = clouds.cloud_in_iterable(
+        clouds.Kubernetes(),
+        enabled_clouds,
+    )
 
     def _list_to_str(lst):
         return ', '.join([str(e) for e in lst])
 
+    # TODO(zhwu,romilb): We should move most of these kubernetes related
+    # queries into the backend, especially behind the server.
     def _get_kubernetes_realtime_gpu_table(
+            context: Optional[str] = None,
             name_filter: Optional[str] = None,
             quantity_filter: Optional[int] = None):
         if quantity_filter:
             qty_header = 'QTY_FILTER'
             free_header = 'FILTERED_FREE_GPUS'
         else:
-            qty_header = 'QTY_PER_NODE'
+            qty_header = 'REQUESTABLE_QTY_PER_NODE'
             free_header = 'TOTAL_FREE_GPUS'
         realtime_gpu_table = log_utils.create_table(
             ['GPU', qty_header, 'TOTAL_GPUS', free_header])
-        counts, capacity, available = service_catalog.list_accelerator_realtime(
-            gpus_only=True,
-            clouds='kubernetes',
-            name_filter=name_filter,
-            region_filter=region,
-            quantity_filter=quantity_filter,
-            case_sensitive=False)
-        assert (set(counts.keys()) == set(capacity.keys()) == set(
-            available.keys())), (f'Keys of counts ({list(counts.keys())}), '
-                                 f'capacity ({list(capacity.keys())}), '
-                                 f'and available ({list(available.keys())}) '
-                                 'must be same.')
-        if len(counts) == 0:
+        realtime_gpu_availability_list = sdk.stream_and_get(
+            sdk.realtime_kubernetes_gpu_availability(
+                context=context,
+                name_filter=name_filter,
+                quantity_filter=quantity_filter))
+        if not realtime_gpu_availability_list:
             err_msg = 'No GPUs found in Kubernetes cluster. '
             debug_msg = 'To further debug, run: sky check '
             if name_filter is not None:
@@ -3062,17 +3337,43 @@ def show_gpus(
                            'in Kubernetes cluster. ')
                 debug_msg = ('To show available accelerators on kubernetes,'
                              ' run: sky show-gpus --cloud kubernetes ')
-            full_err_msg = (err_msg + kubernetes_utils.NO_GPU_HELP_MESSAGE +
+            full_err_msg = (err_msg + kubernetes_constants.NO_GPU_HELP_MESSAGE +
                             debug_msg)
             raise ValueError(full_err_msg)
-        for gpu, _ in sorted(counts.items()):
+        no_permissions_str = '<no permissions>'
+        for realtime_gpu_availability in sorted(realtime_gpu_availability_list):
+            gpu_availability = models.RealtimeGpuAvailability(
+                *realtime_gpu_availability)
+            available_qty = (gpu_availability.available
+                             if gpu_availability.available != -1 else
+                             no_permissions_str)
             realtime_gpu_table.add_row([
-                gpu,
-                _list_to_str(counts.pop(gpu)), capacity[gpu], available[gpu]
+                gpu_availability.gpu,
+                _list_to_str(gpu_availability.counts),
+                gpu_availability.capacity,
+                available_qty,
             ])
         return realtime_gpu_table
 
-    def _output():
+    # TODO(zhwu): this needs to run on remote server.
+    def _get_kubernetes_node_info_table(context: Optional[str]):
+        node_table = log_utils.create_table(
+            ['NODE_NAME', 'GPU_NAME', 'TOTAL_GPUS', 'FREE_GPUS'])
+
+        no_permissions_str = '<no permissions>'
+        node_info_dict = sdk.stream_and_get(
+            sdk.kubernetes_node_info(context=context))
+        for node_name, node_info in node_info_dict.items():
+            available = node_info.free[
+                'accelerators_available'] if node_info.free[
+                    'accelerators_available'] != -1 else no_permissions_str
+            node_table.add_row([
+                node_name, node_info.accelerator_type,
+                node_info.total['accelerator_count'], available
+            ])
+        return node_table
+
+    def _output() -> Generator[str, None, None]:
         gpu_table = log_utils.create_table(
             ['COMMON_GPU', 'AVAILABLE_QUANTITIES'])
         tpu_table = log_utils.create_table(
@@ -3085,8 +3386,8 @@ def show_gpus(
         # Optimization - do not poll for Kubernetes API for fetching
         # common GPUs because that will be fetched later for the table after
         # common GPUs.
-        clouds_to_list = cloud
-        if cloud is None:
+        clouds_to_list: Union[Optional[str], List[str]] = cloud_name
+        if cloud_name is None:
             clouds_to_list = [
                 c for c in service_catalog.ALL_CLOUDS if c != 'kubernetes'
             ]
@@ -3096,12 +3397,16 @@ def show_gpus(
             # Collect k8s related messages in k8s_messages and print them at end
             print_section_titles = False
             # If cloud is kubernetes, we want to show real-time capacity
-            if kubernetes_is_enabled and (cloud is None or cloud_is_kubernetes):
+            if kubernetes_is_enabled and (cloud_name is None or
+                                          cloud_is_kubernetes):
+                context = region
+
                 try:
                     # If --cloud kubernetes is not specified, we want to catch
                     # the case where no GPUs are available on the cluster and
                     # print the warning at the end.
-                    k8s_realtime_table = _get_kubernetes_realtime_gpu_table()
+                    k8s_realtime_table = _get_kubernetes_realtime_gpu_table(
+                        context)
                 except ValueError as e:
                     if not cloud_is_kubernetes:
                         # Make it a note if cloud is not kubernetes
@@ -3109,9 +3414,27 @@ def show_gpus(
                     k8s_messages += str(e)
                 else:
                     print_section_titles = True
+                    context_str = f'(Context: {context})' if context else ''
                     yield (f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
-                           f'Kubernetes GPUs{colorama.Style.RESET_ALL}\n')
+                           f'Kubernetes GPUs {context_str}'
+                           f'{colorama.Style.RESET_ALL}\n')
                     yield from k8s_realtime_table.get_string()
+                    k8s_node_table = _get_kubernetes_node_info_table(context)
+                    yield '\n\n'
+                    # TODO(Doyoung): Update the message with the multi-host TPU
+                    # support.
+                    k8s_per_node_acc_message = (
+                        'Kubernetes per node accelerator availability ')
+                    if kubernetes_utils.multi_host_tpu_exists_in_cluster(
+                            context):
+                        k8s_per_node_acc_message += (
+                            '(Note: Multi-host TPUs are detected and excluded '
+                            'from the display as multi-host TPUs are not '
+                            'supported.)')
+                    yield (f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                           f'{k8s_per_node_acc_message}'
+                           f'{colorama.Style.RESET_ALL}\n')
+                    yield from k8s_node_table.get_string()
                 if kubernetes_autoscaling:
                     k8s_messages += (
                         '\n' + kubernetes_utils.KUBERNETES_AUTOSCALER_NOTE)
@@ -3129,11 +3452,14 @@ def show_gpus(
                 yield k8s_messages
                 yield '\n\n'
 
-            result = service_catalog.list_accelerator_counts(
-                gpus_only=True,
-                clouds=clouds_to_list,
-                region_filter=region,
-            )
+            result = sdk.stream_and_get(
+                sdk.list_accelerator_counts(
+                    gpus_only=True,
+                    clouds=clouds_to_list,
+                    region_filter=region,
+                ))
+            # TODO(zhwu): handle the case where no accelerators are found,
+            # especially when --region specified a non-existent region.
 
             if print_section_titles:
                 # If section titles were printed above, print again here
@@ -3151,7 +3477,7 @@ def show_gpus(
             for tpu in service_catalog.get_tpus():
                 if tpu in result:
                     tpu_table.add_row([tpu, _list_to_str(result.pop(tpu))])
-            if len(tpu_table.get_string()) > 0:
+            if tpu_table.get_string():
                 yield '\n\n'
             yield from tpu_table.get_string()
 
@@ -3192,13 +3518,14 @@ def show_gpus(
                 name, quantity = accelerator_str, None
 
         print_section_titles = False
-        if (kubernetes_is_enabled and (cloud is None or cloud_is_kubernetes) and
-                not show_all):
+        if (kubernetes_is_enabled and
+            (cloud_name is None or cloud_is_kubernetes) and not show_all):
             # Print section title if not showing all and instead a specific
             # accelerator is requested
             print_section_titles = True
             yield (f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                    f'Kubernetes GPUs{colorama.Style.RESET_ALL}\n')
+            # TODO(romilb): Show filtered per node GPU availability here as well
             try:
                 k8s_realtime_table = _get_kubernetes_realtime_gpu_table(
                     name_filter=name, quantity_filter=quantity)
@@ -3220,16 +3547,17 @@ def show_gpus(
 
         # For clouds other than Kubernetes, get the accelerator details
         # Case-sensitive
-        result = service_catalog.list_accelerators(gpus_only=True,
-                                                   name_filter=name,
-                                                   quantity_filter=quantity,
-                                                   region_filter=region,
-                                                   clouds=clouds_to_list,
-                                                   case_sensitive=False,
-                                                   all_regions=all_regions)
+        result = sdk.stream_and_get(
+            sdk.list_accelerators(gpus_only=True,
+                                  name_filter=name,
+                                  quantity_filter=quantity,
+                                  region_filter=region,
+                                  clouds=clouds_to_list,
+                                  case_sensitive=False,
+                                  all_regions=all_regions))
         # Import here to save module load speed.
         # pylint: disable=import-outside-toplevel,line-too-long
-        from sky.clouds.service_catalog import common
+        from sky.clouds.service_catalog import common as catalog_common
 
         # For each gpu name (count not included):
         #   - Group by cloud
@@ -3250,7 +3578,7 @@ def show_gpus(
             df = df.sort_values(by=['min_price', 'min_spot_price'])
             df = df.drop(columns=['min_price', 'min_spot_price'])
             sorted_dataclasses = [
-                common.InstanceTypeInfo(*row)
+                catalog_common.InstanceTypeInfo(*row)
                 for row in df.to_records(index=False)
             ]
             new_result[gpu] = sorted_dataclasses
@@ -3261,10 +3589,10 @@ def show_gpus(
             yield (f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                    f'Cloud GPUs{colorama.Style.RESET_ALL}\n')
 
-        if len(result) == 0:
+        if not result:
             quantity_str = (f' with requested quantity {quantity}'
                             if quantity else '')
-            cloud_str = f' on {cloud_obj}.' if cloud else ' in cloud catalogs.'
+            cloud_str = f' on {cloud_obj}.' if cloud_name else ' in cloud catalogs.'
             yield f'Resources \'{name}\'{quantity_str} not found{cloud_str} '
             yield 'To show available accelerators, run: sky show-gpus --all'
             return
@@ -3325,10 +3653,11 @@ def show_gpus(
                 yield '\n\n'
             yield from accelerator_table.get_string()
 
+    outputs = _output()
     if show_all:
-        click.echo_via_pager(_output())
+        click.echo_via_pager(outputs)
     else:
-        for out in _output():
+        for out in outputs:
             click.echo(out, nl=False)
         click.echo()
 
@@ -3340,18 +3669,20 @@ def storage():
 
 
 @storage.command('ls', cls=_DocumentedCodeCommand)
-@click.option('--all',
-              '-a',
+@click.option('--verbose',
+              '-v',
               default=False,
               is_flag=True,
               required=False,
               help='Show all information in full.')
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def storage_ls(all: bool):
+def storage_ls(verbose: bool):
     """List storage objects managed by SkyPilot."""
-    storages = sky.storage_ls()
-    storage_table = storage_utils.format_storage_table(storages, show_all=all)
+    request_id = sdk.storage_ls()
+    storages = sdk.stream_and_get(request_id)
+    storage_table = storage_utils.format_storage_table(storages,
+                                                       show_all=verbose)
     click.echo(storage_table)
 
 
@@ -3373,8 +3704,9 @@ def storage_ls(all: bool):
               is_flag=True,
               required=False,
               help='Skip confirmation prompt.')
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
-def storage_delete(names: List[str], all: bool, yes: bool):  # pylint: disable=redefined-builtin
+def storage_delete(names: List[str], all: bool, yes: bool, async_call: bool):  # pylint: disable=redefined-builtin
     """Delete storage objects.
 
     Examples:
@@ -3390,14 +3722,13 @@ def storage_delete(names: List[str], all: bool, yes: bool):  # pylint: disable=r
         # Delete all storage objects.
         sky storage delete -a
     """
-    if sum([len(names) > 0, all]) != 1:
+    if sum([bool(names), all]) != 1:
         raise click.UsageError('Either --all or a name must be specified.')
     if all:
-        storages = sky.storage_ls()
+        storages = sdk.get(sdk.storage_ls())
         if not storages:
             click.echo('No storage(s) to delete.')
             return
-        names = [s['name'] for s in storages]
     else:
         names = _get_glob_storages(names)
     if names:
@@ -3411,13 +3742,25 @@ def storage_delete(names: List[str], all: bool, yes: bool):  # pylint: disable=r
                 abort=True,
                 show_default=True)
 
-    subprocess_utils.run_in_parallel(sky.storage_delete, names)
+    request_ids = {}
+    # TODO(zhwu): Support all flag for the underlying SDK and API server to
+    # avoid multiple requests.
+    for name in names:
+        request_ids[name] = sdk.storage_delete(name)
 
+    for name, request_id in request_ids.items():
+        try:
+            _async_call_or_wait(request_id, async_call, 'sky.storage')
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(f'{colorama.Fore.RED}Error deleting storage {name}: '
+                         f'{common_utils.format_exception(e, use_bracket=True)}'
+                         f'{colorama.Style.RESET_ALL}')
 
-@cli.group(cls=_NaturalOrderGroup)
+
+@cli.group(cls=_NaturalOrderGroup, hidden=True)
 def bench():
     """SkyPilot Benchmark CLI."""
-    pass
+    raise click.UsageError('The benchmark CLI is currently disabled.')
 
 
 @cli.group(cls=_NaturalOrderGroup)
@@ -3433,13 +3776,14 @@ def jobs():
                 nargs=-1,
                 **_get_shell_complete_args(_complete_file_name))
 # TODO(zhwu): Add --dryrun option to test the launch command.
-@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS)
+@_add_click_options(_TASK_OPTIONS_WITH_NAME + _EXTRA_RESOURCES_OPTIONS +
+                    _COMMON_OPTIONS)
 @click.option('--cluster',
               '-c',
               default=None,
               type=str,
               hidden=True,
-              help=('Alias for --name, the name of the spot job.'))
+              help=('Alias for --name, the name of the managed job.'))
 @click.option('--job-recovery',
               default=None,
               type=str,
@@ -3451,18 +3795,6 @@ def jobs():
     is_flag=True,
     help=('If True, as soon as a job is submitted, return from this call '
           'and do not stream execution logs.'))
-@click.option(
-    '--retry-until-up/--no-retry-until-up',
-    '-r/-no-r',
-    default=None,
-    is_flag=True,
-    required=False,
-    help=(
-        '(Default: True; this flag is deprecated and will be removed in a '
-        'future release.) Whether to retry provisioning infinitely until the '
-        'cluster is up, if unavailability errors are encountered. This '  # pylint: disable=bad-docstring-quotes
-        'applies to launching all managed jobs (both the initial and '
-        'any recovery attempts), not the jobs controller.'))
 @click.option('--yes',
               '-y',
               is_flag=True,
@@ -3493,8 +3825,8 @@ def jobs_launch(
     disk_tier: Optional[str],
     ports: Tuple[str],
     detach_run: bool,
-    retry_until_up: bool,
     yes: bool,
+    async_call: bool,
 ):
     """Launch a managed job from a YAML or a command.
 
@@ -3536,19 +3868,6 @@ def jobs_launch(
         ports=ports,
         job_recovery=job_recovery,
     )
-    # Deprecation. We set the default behavior to be retry until up, and the
-    # flag `--retry-until-up` is deprecated. We can remove the flag in 0.8.0.
-    if retry_until_up is not None:
-        flag_str = '--retry-until-up'
-        if not retry_until_up:
-            flag_str = '--no-retry-until-up'
-        click.secho(
-            f'Flag {flag_str} is deprecated and will be removed in a '
-            'future release (managed jobs will always be retried). '
-            'Please file an issue if this does not work for you.',
-            fg='yellow')
-    else:
-        retry_until_up = True
 
     if not isinstance(task_or_dag, sky.Dag):
         assert isinstance(task_or_dag, sky.Task), task_or_dag
@@ -3564,26 +3883,25 @@ def jobs_launch(
     dag_utils.maybe_infer_and_fill_dag_and_task_names(dag)
     dag_utils.fill_default_config_in_dag_for_job_launch(dag)
 
+    common_utils.check_cluster_name_is_valid(name)
+
     click.secho(f'Managed job {dag.name!r} will be launched on (estimated):',
                 fg='yellow')
-    dag = sky.optimize(dag)
-
-    if not yes:
-        prompt = f'Launching a managed job {dag.name!r}. Proceed?'
-        if prompt is not None:
-            click.confirm(prompt, default=True, abort=True, show_default=True)
-
-    common_utils.check_cluster_name_is_valid(name)
 
-    managed_jobs.launch(dag,
-                        name,
-                        detach_run=detach_run,
-                        retry_until_up=retry_until_up)
+    request_id = managed_jobs.launch(dag, name, _need_confirmation=not yes)
+    job_id_handle = _async_call_or_wait(request_id, async_call,
+                                        'sky.jobs.launch')
+    if not async_call and not detach_run:
+        job_id = job_id_handle[0]
+        managed_jobs.tail_logs(name=None,
+                               job_id=job_id,
+                               follow=True,
+                               controller=False)
 
 
 @jobs.command('queue', cls=_DocumentedCodeCommand)
-@click.option('--all',
-              '-a',
+@click.option('--verbose',
+              '-v',
               default=False,
               is_flag=True,
               required=False,
@@ -3602,9 +3920,16 @@ def jobs_launch(
               is_flag=True,
               required=False,
               help='Show only pending/running jobs\' information.')
+@click.option('--all-users',
+              '-u',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Show jobs from all users.')
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def jobs_queue(all: bool, refresh: bool, skip_finished: bool):
+def jobs_queue(verbose: bool, refresh: bool, skip_finished: bool,
+               all_users: bool):
     """Show statuses of managed jobs.
 
     Each managed jobs can have one of the following statuses:
@@ -3658,12 +3983,14 @@ def jobs_queue(all: bool, refresh: bool, skip_finished: bool):
       watch -n60 sky jobs queue
 
     """
-    click.secho('Fetching managed job statuses...', fg='yellow')
-    with rich_utils.safe_status('[cyan]Checking managed jobs[/]'):
-        _, msg = _get_managed_jobs(refresh=refresh,
-                                   skip_finished=skip_finished,
-                                   show_all=all,
-                                   is_called_by_user=True)
+    click.secho('Fetching managed job statuses...', fg='cyan')
+    with rich_utils.client_status('[cyan]Checking managed jobs[/]'):
+        managed_jobs_request_id = managed_jobs.queue(
+            refresh=refresh, skip_finished=skip_finished, all_users=all_users)
+        _, msg = _handle_jobs_queue_request(managed_jobs_request_id,
+                                            show_all=verbose,
+                                            show_user=all_users,
+                                            is_called_by_user=True)
     if not skip_finished:
         in_progress_only_hint = ''
     else:
@@ -3685,16 +4012,23 @@ def jobs_queue(all: bool, refresh: bool, skip_finished: bool):
               is_flag=True,
               default=False,
               required=False,
-              help='Cancel all managed jobs.')
+              help='Cancel all managed jobs for the current user.')
 @click.option('--yes',
               '-y',
               is_flag=True,
               default=False,
               required=False,
               help='Skip confirmation prompt.')
+@click.option('--all-users',
+              '-u',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Cancel all managed jobs from all users.')
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def jobs_cancel(name: Optional[str], job_ids: Tuple[int], all: bool, yes: bool):
+def jobs_cancel(name: Optional[str], job_ids: Tuple[int], all: bool, yes: bool,
+                all_users: bool):
     """Cancel managed jobs.
 
     You can provide either a job name or a list of job IDs to be cancelled.
@@ -3710,31 +4044,34 @@ def jobs_cancel(name: Optional[str], job_ids: Tuple[int], all: bool, yes: bool):
       # Cancel managed jobs with IDs 1, 2, 3
       $ sky jobs cancel 1 2 3
     """
-    backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.JOBS_CONTROLLER,
-        stopped_message='All managed jobs should have finished.',
-        exit_if_not_accessible=True)
-
     job_id_str = ','.join(map(str, job_ids))
-    if sum([len(job_ids) > 0, name is not None, all]) != 1:
-        argument_str = f'--job-ids {job_id_str}' if len(job_ids) > 0 else ''
-        argument_str += f' --name {name}' if name is not None else ''
-        argument_str += ' --all' if all else ''
+    if sum([bool(job_ids), name is not None, all or all_users]) != 1:
+        arguments = []
+        arguments += [f'--job-ids {job_id_str}'] if job_ids else []
+        arguments += [f'--name {name}'] if name is not None else []
+        arguments += ['--all'] if all else []
+        arguments += ['--all-users'] if all_users else []
         raise click.UsageError(
-            'Can only specify one of JOB_IDS or --name or --all. '
-            f'Provided {argument_str!r}.')
+            'Can only specify one of JOB_IDS, --name, or --all/--all-users. '
+            f'Provided {" ".join(arguments)!r}.')
 
     if not yes:
         job_identity_str = (f'managed jobs with IDs {job_id_str}'
                             if job_ids else repr(name))
-        if all:
+        if all_users:
+            job_identity_str = 'all managed jobs FOR ALL USERS'
+        elif all:
             job_identity_str = 'all managed jobs'
         click.confirm(f'Cancelling {job_identity_str}. Proceed?',
                       default=True,
                       abort=True,
                       show_default=True)
 
-    managed_jobs.cancel(job_ids=job_ids, name=name, all=all)
+    sdk.stream_and_get(
+        managed_jobs.cancel(job_ids=job_ids,
+                            name=name,
+                            all=all,
+                            all_users=all_users))
 
 
 @jobs.command('logs', cls=_DocumentedCodeCommand)
@@ -3755,97 +4092,56 @@ def jobs_cancel(name: Optional[str], job_ids: Tuple[int], all: bool, yes: bool):
     default=False,
     help=('Show the controller logs of this job; useful for debugging '
           'launching/recoveries, etc.'))
+@click.option(
+    '--refresh',
+    '-r',
+    default=False,
+    is_flag=True,
+    required=False,
+    help='Query the latest job logs, restarting the jobs controller if stopped.'
+)
+@click.option('--sync-down',
+              '-s',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Download logs for all jobs shown in the queue.')
 @click.argument('job_id', required=False, type=int)
 @usage_lib.entrypoint
 def jobs_logs(name: Optional[str], job_id: Optional[int], follow: bool,
-              controller: bool):
-    """Tail the log of a managed job."""
+              controller: bool, refresh: bool, sync_down: bool):
+    """Tail or sync down the log of a managed job."""
     try:
-        managed_jobs.tail_logs(name=name,
-                               job_id=job_id,
-                               follow=follow,
-                               controller=controller)
+        if sync_down:
+            with rich_utils.client_status(
+                    ux_utils.spinner_message('Downloading jobs logs')):
+                log_local_path_dict = managed_jobs.download_logs(
+                    name=name,
+                    job_id=job_id,
+                    controller=controller,
+                    refresh=refresh)
+            style = colorama.Style
+            fore = colorama.Fore
+            controller_str = ' (controller)' if controller else ''
+            for job, log_local_path in log_local_path_dict.items():
+                logger.info(f'{fore.CYAN}Job {job} logs{controller_str}: '
+                            f'{log_local_path}{style.RESET_ALL}')
+        else:
+            managed_jobs.tail_logs(name=name,
+                                   job_id=job_id,
+                                   follow=follow,
+                                   controller=controller,
+                                   refresh=refresh)
     except exceptions.ClusterNotUpError:
         with ux_utils.print_exception_no_traceback():
             raise
 
 
 @jobs.command('dashboard', cls=_DocumentedCodeCommand)
-@click.option(
-    '--port',
-    '-p',
-    default=None,
-    type=int,
-    required=False,
-    help=('Local port to use for the dashboard. If None, a free port is '
-          'automatically chosen.'))
 @usage_lib.entrypoint
-def jobs_dashboard(port: Optional[int]):
-    """Opens a dashboard for managed jobs (needs controller to be UP)."""
-    # TODO(zongheng): ideally, the controller/dashboard server should expose the
-    # API perhaps via REST. Then here we would (1) not have to use SSH to try to
-    # see if the controller is UP first, which is slow; (2) not have to run SSH
-    # port forwarding first (we'd just launch a local dashboard which would make
-    # REST API calls to the controller dashboard server).
-    click.secho('Checking if jobs controller is up...', fg='yellow')
-    hint = ('Dashboard is not available if jobs controller is not up. Run a '
-            'managed job first.')
-    backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.JOBS_CONTROLLER,
-        stopped_message=hint,
-        non_existent_message=hint,
-        exit_if_not_accessible=True)
-
-    # SSH forward a free local port to remote's dashboard port.
-    remote_port = constants.SPOT_DASHBOARD_REMOTE_PORT
-    if port is None:
-        free_port = common_utils.find_free_port(remote_port)
-    else:
-        free_port = port
-    ssh_command = (
-        f'ssh -qNL {free_port}:localhost:{remote_port} '
-        f'{controller_utils.Controllers.JOBS_CONTROLLER.value.cluster_name}')
-    click.echo('Forwarding port: ', nl=False)
-    click.secho(f'{ssh_command}', dim=True)
-
-    with subprocess.Popen(ssh_command, shell=True,
-                          start_new_session=True) as ssh_process:
-        time.sleep(3)  # Added delay for ssh_command to initialize.
-        webbrowser.open(f'http://localhost:{free_port}')
-        click.secho(
-            f'Dashboard is now available at: http://127.0.0.1:{free_port}',
-            fg='green')
-        try:
-            ssh_process.wait()
-        except KeyboardInterrupt:
-            # When user presses Ctrl-C in terminal, exits the previous ssh
-            # command so that <free local port> is freed up.
-            try:
-                os.killpg(os.getpgid(ssh_process.pid), signal.SIGTERM)
-            except ProcessLookupError:
-                # This happens if jobs controller is auto-stopped.
-                pass
-        finally:
-            click.echo('Exiting.')
-
-
-# TODO(zhwu): Backward compatibility for the old `sky spot launch` command.
-# It is now renamed to `sky jobs launch` and the old command is deprecated.
-# Remove in v0.8.0.
-@cli.group(cls=_NaturalOrderGroup)
-def spot():
-    """Alias for Managed Jobs CLI (default to managed spot jobs)."""
-    pass
-
-
-_add_command_alias(jobs,
-                   jobs_launch,
-                   new_group=spot,
-                   override_command_argument={'use_spot': True})
-_add_command_alias(jobs, jobs_queue, new_group=spot)
-_add_command_alias(jobs, jobs_logs, new_group=spot)
-_add_command_alias(jobs, jobs_cancel, new_group=spot)
-_add_command_alias(jobs, jobs_dashboard, new_group=spot)
+def jobs_dashboard():
+    """Opens a dashboard for managed jobs."""
+    managed_jobs.dashboard()
 
 
 @cli.group(cls=_NaturalOrderGroup)
@@ -3868,7 +4164,7 @@ def _generate_task_with_service(
     env: List[Tuple[str, str]],
     gpus: Optional[str],
     instance_type: Optional[str],
-    ports: Tuple[str],
+    ports: Optional[Tuple[str]],
     cpus: Optional[str],
     memory: Optional[str],
     disk_size: Optional[int],
@@ -3900,7 +4196,6 @@ def _generate_task_with_service(
         disk_size=disk_size,
         disk_tier=disk_tier,
         ports=ports,
-        entrypoint_name='Service',
     )
     if isinstance(task, sky.Dag):
         raise click.UsageError(
@@ -3910,32 +4205,64 @@ def _generate_task_with_service(
         with ux_utils.print_exception_no_traceback():
             raise ValueError('Service section not found in the YAML file. '
                              'To fix, add a valid `service` field.')
-    service_port: Optional[int] = None
-    for requested_resources in list(task.resources):
-        if requested_resources.ports is None or len(
-                requested_resources.ports) != 1:
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(
-                    'Must only specify one port in resources. Each replica '
-                    'will use the port specified as application ingress port.')
-        service_port_str = requested_resources.ports[0]
-        if not service_port_str.isdigit():
-            # For the case when the user specified a port range like 10000-10010
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(f'Port {service_port_str!r} is not a valid '
-                                 'port number. Please specify a single port '
-                                 f'instead. Got: {service_port_str!r}')
-        # We request all the replicas using the same port for now, but it
-        # should be fine to allow different replicas to use different ports
-        # in the future.
-        resource_port = int(service_port_str)
-        if service_port is None:
-            service_port = resource_port
-        if service_port != resource_port:
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(f'Got multiple ports: {service_port} and '
-                                 f'{resource_port} in different resources. '
-                                 'Please specify single port instead.')
+
+    # NOTE(yi): we only allow one service port now.
+    service_port: Optional[int] = int(
+        task.service.ports) if task.service.ports is not None else None
+    if service_port is None:
+        for requested_resources in list(task.resources):
+            if requested_resources.ports is None:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        'Must specify at least one ports in resources. Each '
+                        'replica will use the port specified as application '
+                        'ingress port if only one port is specified in the '
+                        'replica resources. If there are multiple ports opened '
+                        'in the replica, please set the `service.ports` field '
+                        'in the service config.')
+            requested_ports = list(
+                resources_utils.port_ranges_to_set(requested_resources.ports))
+            if len(requested_ports) > 1:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        'Multiple ports specified in resources. Please '
+                        'specify the main port in the `service.ports` field.')
+            # We request all the replicas using the same port for now, but it
+            # should be fine to allow different replicas to use different ports
+            # in the future.
+            resource_port = requested_ports[0]
+            if service_port is None:
+                service_port = resource_port
+            if service_port != resource_port:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        f'Got multiple ports: {service_port} and '
+                        f'{resource_port} in different resources. '
+                        'Please specify the same port in all replicas, or '
+                        'explicitly set the service port in the '
+                        '`service.ports` section.')
+        assert service_port is not None
+        task.service.set_ports(str(service_port))
+    else:
+        for requested_resources in list(task.resources):
+            if requested_resources.ports is None:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        'Must specify at least one ports in every replica '
+                        'resources.')
+            ports_set = resources_utils.port_ranges_to_set(
+                requested_resources.ports)
+            if service_port not in ports_set:
+                with ux_utils.print_exception_no_traceback():
+                    # TODO(tian): Automatically infer resource port from
+                    # service port if none of them is specified in the
+                    # replica resources.
+                    raise ValueError(
+                        f'The service port {service_port} specified in the '
+                        'service section is not found in some resources. '
+                        'Please check if the service port is correct or add '
+                        'the service port to replica resources.')
+
     return task
 
 
@@ -3951,7 +4278,7 @@ def _generate_task_with_service(
               type=str,
               help='A service name. Unique for each service. If not provided, '
               'a unique name is autogenerated.')
-@_add_click_options(_TASK_OPTIONS + _EXTRA_RESOURCES_OPTIONS)
+@_add_click_options(_TASK_OPTIONS + _EXTRA_RESOURCES_OPTIONS + _COMMON_OPTIONS)
 @click.option('--yes',
               '-y',
               is_flag=True,
@@ -3980,6 +4307,7 @@ def serve_up(
     disk_size: Optional[int],
     disk_tier: Optional[str],
     yes: bool,
+    async_call: bool,
 ):
     """Launch a SkyServe service.
 
@@ -4033,21 +4361,16 @@ def serve_up(
         ports=ports,
         not_supported_cmd='sky serve up',
     )
-    click.secho('Service Spec:', fg='cyan')
+    click.secho('Service spec:', fg='cyan')
     click.echo(task.service)
 
     click.secho('Each replica will use the following resources (estimated):',
                 fg='cyan')
     with sky.Dag() as dag:
         dag.add(task)
-    sky.optimize(dag)
-
-    if not yes:
-        prompt = f'Launching a new service {service_name!r}. Proceed?'
-        if prompt is not None:
-            click.confirm(prompt, default=True, abort=True, show_default=True)
 
-    serve_lib.up(task, service_name)
+    request_id = serve_lib.up(task, service_name, _need_confirmation=not yes)
+    _async_call_or_wait(request_id, async_call, 'sky.serve.up')
 
 
 # TODO(MaoZiming): Update Doc.
@@ -4060,7 +4383,7 @@ def serve_up(
                 type=str,
                 nargs=-1,
                 **_get_shell_complete_args(_complete_file_name))
-@_add_click_options(_TASK_OPTIONS + _EXTRA_RESOURCES_OPTIONS)
+@_add_click_options(_TASK_OPTIONS + _EXTRA_RESOURCES_OPTIONS + _COMMON_OPTIONS)
 @click.option('--mode',
               default=serve_lib.DEFAULT_UPDATE_MODE.value,
               type=click.Choice([m.value for m in serve_lib.UpdateMode],
@@ -4077,28 +4400,16 @@ def serve_up(
               help='Skip confirmation prompt.')
 @timeline.event
 @usage_lib.entrypoint
-def serve_update(
-    service_name: str,
-    service_yaml: Tuple[str, ...],
-    workdir: Optional[str],
-    cloud: Optional[str],
-    region: Optional[str],
-    zone: Optional[str],
-    num_nodes: Optional[int],
-    use_spot: Optional[bool],
-    image_id: Optional[str],
-    env_file: Optional[Dict[str, str]],
-    env: List[Tuple[str, str]],
-    gpus: Optional[str],
-    instance_type: Optional[str],
-    ports: Tuple[str],
-    cpus: Optional[str],
-    memory: Optional[str],
-    disk_size: Optional[int],
-    disk_tier: Optional[str],
-    mode: str,
-    yes: bool,
-):
+def serve_update(service_name: str, service_yaml: Tuple[str, ...],
+                 workdir: Optional[str], cloud: Optional[str],
+                 region: Optional[str], zone: Optional[str],
+                 num_nodes: Optional[int], use_spot: Optional[bool],
+                 image_id: Optional[str], env_file: Optional[Dict[str, str]],
+                 env: List[Tuple[str, str]], gpus: Optional[str],
+                 instance_type: Optional[str], ports: Tuple[str],
+                 cpus: Optional[str], memory: Optional[str],
+                 disk_size: Optional[int], disk_tier: Optional[str], mode: str,
+                 yes: bool, async_call: bool):
     """Update a SkyServe service.
 
     service_yaml must point to a valid YAML file.
@@ -4149,27 +4460,24 @@ def serve_update(
         ports=ports,
         not_supported_cmd='sky serve update',
     )
-    click.secho('Service Spec:', fg='cyan')
+    click.secho('Service spec:', fg='cyan')
     click.echo(task.service)
 
     click.secho('New replica will use the following resources (estimated):',
                 fg='cyan')
     with sky.Dag() as dag:
         dag.add(task)
-    sky.optimize(dag)
 
-    if not yes:
-        click.confirm(f'Updating service {service_name!r}. Proceed?',
-                      default=True,
-                      abort=True,
-                      show_default=True)
-
-    serve_lib.update(task, service_name, mode=serve_lib.UpdateMode(mode))
+    request_id = serve_lib.update(task,
+                                  service_name,
+                                  mode=serve_lib.UpdateMode(mode),
+                                  _need_confirmation=not yes)
+    _async_call_or_wait(request_id, async_call, 'sky.serve.update')
 
 
 @serve.command('status', cls=_DocumentedCodeCommand)
-@click.option('--all',
-              '-a',
+@click.option('--verbose',
+              '-v',
               default=False,
               is_flag=True,
               required=False,
@@ -4182,7 +4490,7 @@ def serve_update(
 @click.argument('service_names', required=False, type=str, nargs=-1)
 @usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def serve_status(all: bool, endpoint: bool, service_names: List[str]):
+def serve_status(verbose: bool, endpoint: bool, service_names: List[str]):
     """Show statuses of SkyServe services.
 
     Show detailed statuses of one or more services. If SERVICE_NAME is not
@@ -4269,17 +4577,22 @@ def serve_status(all: bool, endpoint: bool, service_names: List[str]):
       sky serve status
       \b
       # Show detailed status for all services
-      sky serve status -a
+      sky serve status -v
       \b
       # Only show status of my-service
       sky serve status my-service
     """
+    service_names_to_query: Optional[List[str]] = service_names
+    if not service_names:
+        service_names_to_query = None
     # This won't pollute the output of --endpoint.
-    with rich_utils.safe_status('[cyan]Checking services[/]'):
-        _, msg = _get_services(service_names,
-                               show_all=all,
-                               show_endpoint=endpoint,
-                               is_called_by_user=True)
+    with rich_utils.client_status('[cyan]Checking services[/]'):
+        service_status_request_id = serve_lib.status(service_names_to_query)
+        _, msg = _handle_services_request(service_status_request_id,
+                                          service_names=service_names_to_query,
+                                          show_all=verbose,
+                                          show_endpoint=endpoint,
+                                          is_called_by_user=True)
 
     if not endpoint:
         click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
@@ -4305,8 +4618,21 @@ def serve_status(all: bool, endpoint: bool, service_names: List[str]):
               default=False,
               required=False,
               help='Skip confirmation prompt.')
+@click.option('--replica-id',
+              default=None,
+              type=int,
+              help='Tear down a given replica')
+@_add_click_options(_COMMON_OPTIONS)
+@usage_lib.entrypoint
 # pylint: disable=redefined-builtin
-def serve_down(service_names: List[str], all: bool, purge: bool, yes: bool):
+def serve_down(
+    service_names: List[str],
+    all: bool,
+    purge: bool,
+    yes: bool,
+    replica_id: Optional[int],
+    async_call: bool,
+) -> None:
     """Teardown service(s).
 
     SERVICE_NAMES is the name of the service (or glob pattern) to tear down. If
@@ -4333,31 +4659,58 @@ def serve_down(service_names: List[str], all: bool, purge: bool, yes: bool):
         \b
         # Forcefully tear down a service in failed status.
         sky serve down failed-service --purge
+        \b
+        # Tear down a specific replica
+        sky serve down my-service --replica-id 1
+        \b
+        # Forcefully tear down a specific replica, even in failed status.
+        sky serve down my-service --replica-id 1 --purge
     """
-    if sum([len(service_names) > 0, all]) != 1:
-        argument_str = f'SERVICE_NAMES={",".join(service_names)}' if len(
-            service_names) > 0 else ''
+    if sum([bool(service_names), all]) != 1:
+        argument_str = (f'SERVICE_NAMES={",".join(service_names)}'
+                        if service_names else '')
         argument_str += ' --all' if all else ''
         raise click.UsageError(
             'Can only specify one of SERVICE_NAMES or --all. '
             f'Provided {argument_str!r}.')
 
-    backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.SKY_SERVE_CONTROLLER,
-        stopped_message='All services should have been terminated.',
-        exit_if_not_accessible=True)
-
-    if not yes:
-        quoted_service_names = [f'{name!r}' for name in service_names]
-        service_identity_str = f'service(s) {", ".join(quoted_service_names)}'
+    replica_id_is_defined = replica_id is not None
+    if replica_id_is_defined:
+        if len(service_names) != 1:
+            service_names_str = ', '.join(service_names)
+            raise click.UsageError(f'The --replica-id option can only be used '
+                                   f'with a single service name. Got: '
+                                   f'{service_names_str}.')
         if all:
-            service_identity_str = 'all services'
-        click.confirm(f'Terminating {service_identity_str}. Proceed?',
-                      default=True,
-                      abort=True,
-                      show_default=True)
-
-    serve_lib.down(service_names=service_names, all=all, purge=purge)
+            raise click.UsageError('The --replica-id option cannot be used '
+                                   'with the --all option.')
+    if not yes:
+        if replica_id_is_defined:
+            click.confirm(
+                f'Terminating replica ID {replica_id} in '
+                f'{service_names[0]!r}. Proceed?',
+                default=True,
+                abort=True,
+                show_default=True)
+        else:
+            quoted_service_names = [f'{name!r}' for name in service_names]
+            list_service_str = ', '.join(quoted_service_names)
+            service_identity_str = f'service(s) {list_service_str}'
+            if all:
+                service_identity_str = 'all services'
+            click.confirm(f'Terminating {service_identity_str}. Proceed?',
+                          default=True,
+                          abort=True,
+                          show_default=True)
+
+    if replica_id_is_defined:
+        request_id = serve_lib.terminate_replica(service_names[0], replica_id,
+                                                 purge)
+    else:
+        request_id = serve_lib.down(service_names=service_names,
+                                    all=all,
+                                    purge=purge)
+    _async_call_or_wait(request_id, async_call, 'sky.serve.down')
 
 
 @serve.command('logs', cls=_DocumentedCodeCommand)
@@ -4484,7 +4837,7 @@ def _get_candidate_configs(yaml_path: str) -> Optional[List[Dict[str, str]]]:
               required=True,
               type=str,
               help='Benchmark name.')
-@_add_click_options(_TASK_OPTIONS_WITH_NAME)
+@_add_click_options(_TASK_OPTIONS_WITH_NAME + _COMMON_OPTIONS)
 @click.option('--gpus',
               required=False,
               type=str,
@@ -4519,26 +4872,27 @@ def _get_candidate_configs(yaml_path: str) -> Optional[List[Dict[str, str]]]:
               help='Skip confirmation prompt.')
 @usage_lib.entrypoint
 def benchmark_launch(
-    entrypoint: str,
-    benchmark: str,
-    name: Optional[str],
-    workdir: Optional[str],
-    cloud: Optional[str],
-    region: Optional[str],
-    zone: Optional[str],
-    gpus: Optional[str],
-    num_nodes: Optional[int],
-    use_spot: Optional[bool],
-    image_id: Optional[str],
-    env_file: Optional[Dict[str, str]],
-    env: List[Tuple[str, str]],
-    cpus: Optional[str],
-    memory: Optional[str],
-    disk_size: Optional[int],
-    disk_tier: Optional[str],
-    ports: Tuple[str],
-    idle_minutes_to_autostop: Optional[int],
-    yes: bool,
+        entrypoint: str,
+        benchmark: str,
+        name: Optional[str],
+        workdir: Optional[str],
+        cloud: Optional[str],
+        region: Optional[str],
+        zone: Optional[str],
+        gpus: Optional[str],
+        num_nodes: Optional[int],
+        use_spot: Optional[bool],
+        image_id: Optional[str],
+        env_file: Optional[Dict[str, str]],
+        env: List[Tuple[str, str]],
+        cpus: Optional[str],
+        memory: Optional[str],
+        disk_size: Optional[int],
+        disk_tier: Optional[str],
+        ports: Tuple[str],
+        idle_minutes_to_autostop: Optional[int],
+        yes: bool,
+        async_call: bool,  # pylint: disable=unused-argument
 ) -> None:
     """Benchmark a task on different resources.
 
@@ -4547,6 +4901,7 @@ def benchmark_launch(
     Alternatively, specify the benchmarking resources in your YAML (see doc),
     which allows benchmarking on many more resource fields.
     """
+    # TODO(zhwu): move benchmark to SkyPilot API server
     env = _merge_env_vars(env_file, env)
     record = benchmark_state.get_benchmark_from_name(benchmark)
     if record is not None:
@@ -4565,7 +4920,7 @@ def benchmark_launch(
             'Please provide a YAML file.')
     assert config is not None, (is_yaml, config)
 
-    click.secho('Benchmarking a task from YAML spec: ', fg='yellow', nl=False)
+    click.secho('Benchmarking a task from YAML: ', fg='cyan', nl=False)
     click.secho(entrypoint, bold=True)
 
     candidates = _get_candidate_configs(entrypoint)
@@ -4686,7 +5041,7 @@ def benchmark_launch(
     if idle_minutes_to_autostop is None:
         idle_minutes_to_autostop = 5
     commandline_args['idle-minutes-to-autostop'] = idle_minutes_to_autostop
-    if len(env) > 0:
+    if env:
         commandline_args['env'] = [f'{k}={v}' for k, v in env]
 
     # Launch the benchmarking clusters in detach mode in parallel.
@@ -4699,11 +5054,11 @@ def benchmark_launch(
             f'\n{colorama.Fore.CYAN}Benchmark name: '
             f'{colorama.Style.BRIGHT}{benchmark}{colorama.Style.RESET_ALL}'
             '\nTo see the benchmark results: '
-            f'{backend_utils.BOLD}sky bench show '
-            f'{benchmark}{backend_utils.RESET_BOLD}'
+            f'{ux_utils.BOLD}sky bench show '
+            f'{benchmark}{ux_utils.RESET_BOLD}'
             '\nTo teardown the clusters: '
-            f'{backend_utils.BOLD}sky bench down '
-            f'{benchmark}{backend_utils.RESET_BOLD}')
+            f'{ux_utils.BOLD}sky bench down '
+            f'{benchmark}{ux_utils.RESET_BOLD}')
         subprocess_utils.run('sky bench ls')
     else:
         logger.error('No benchmarking clusters are created.')
@@ -4937,10 +5292,7 @@ def benchmark_down(
             continue
         to_stop.append(cluster)
 
-    _down_or_stop_clusters(to_stop,
-                           apply_to_all=False,
-                           down=True,
-                           no_confirm=yes)
+    _down_or_stop_clusters(to_stop, down=True, no_confirm=yes)
 
 
 @bench.command('delete', cls=_DocumentedCodeCommand)
@@ -4965,7 +5317,7 @@ def benchmark_delete(benchmarks: Tuple[str], all: Optional[bool],
         raise click.BadParameter(
             'Either specify benchmarks or use --all to delete all benchmarks.')
     to_delete = []
-    if len(benchmarks) > 0:
+    if benchmarks:
         for benchmark in benchmarks:
             record = benchmark_state.get_benchmark_from_name(benchmark)
             if record is None:
@@ -4974,7 +5326,7 @@ def benchmark_delete(benchmarks: Tuple[str], all: Optional[bool],
                 to_delete.append(record)
     if all:
         to_delete = benchmark_state.get_benchmarks()
-        if len(benchmarks) > 0:
+        if benchmarks:
             print('Both --all and benchmark(s) specified '
                   'for sky bench delete. Letting --all take effect.')
 
@@ -5011,8 +5363,8 @@ def benchmark_delete(benchmarks: Tuple[str], all: Optional[bool],
             message = (f'{colorama.Fore.YELLOW}Benchmark {benchmark} '
                        f'has {num_clusters} un-terminated cluster{plural}. '
                        f'Terminate the cluster{plural} with '
-                       f'{backend_utils.BOLD} sky bench down {benchmark} '
-                       f'{backend_utils.RESET_BOLD} '
+                       f'{ux_utils.BOLD} sky bench down {benchmark} '
+                       f'{ux_utils.RESET_BOLD} '
                        'before deleting the benchmark report.')
             success = False
         else:
@@ -5051,181 +5403,276 @@ def local():
               is_flag=True,
               help='Launch cluster without GPU support even '
               'if GPUs are detected on the host.')
+@click.option(
+    '--ips',
+    type=str,
+    required=False,
+    help='Path to the file containing IP addresses of remote machines.')
+@click.option('--ssh-user',
+              type=str,
+              required=False,
+              help='SSH username for accessing remote machines.')
+@click.option('--ssh-key-path',
+              type=str,
+              required=False,
+              help='Path to the SSH private key.')
+@click.option('--cleanup',
+              is_flag=True,
+              help='Clean up the remote cluster instead of deploying it.')
 @local.command('up', cls=_DocumentedCodeCommand)
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
-def local_up(gpus: bool):
-    """Creates a local cluster."""
-    cluster_created = False
-
-    # Check if GPUs are available on the host
-    local_gpus_available = backend_utils.check_local_gpus()
-    gpus = gpus and local_gpus_available
-
-    # Check if ~/.kube/config exists:
-    if os.path.exists(os.path.expanduser('~/.kube/config')):
-        curr_context = kubernetes_utils.get_current_kube_config_context_name()
-        skypilot_context = 'kind-skypilot'
-        if curr_context is not None and curr_context != skypilot_context:
-            click.echo(
-                f'Current context in kube config: {curr_context}'
-                '\nWill automatically switch to kind-skypilot after the local '
-                'cluster is created.')
-    message_str = 'Creating local cluster{}...'
-    message_str = message_str.format((' with GPU support (this may take up '
-                                      'to 15 minutes)') if gpus else '')
-    path_to_package = os.path.dirname(os.path.dirname(__file__))
-    up_script_path = os.path.join(path_to_package, 'sky/utils/kubernetes',
-                                  'create_cluster.sh')
-
-    # Get directory of script and run it from there
-    cwd = os.path.dirname(os.path.abspath(up_script_path))
-    run_command = up_script_path + ' --gpus' if gpus else up_script_path
-    run_command = shlex.split(run_command)
-
-    # Setup logging paths
-    run_timestamp = backend_utils.get_run_timestamp()
-    log_path = os.path.join(constants.SKY_LOGS_DIRECTORY, run_timestamp,
-                            'local_up.log')
-    tail_cmd = 'tail -n100 -f ' + log_path
-
-    click.echo(message_str)
-    style = colorama.Style
-    click.echo('To view detailed progress: '
-               f'{style.BRIGHT}{tail_cmd}{style.RESET_ALL}')
-
-    returncode, _, stderr = log_lib.run_with_log(
-        cmd=run_command,
-        log_path=log_path,
-        require_outputs=True,
-        stream_logs=False,
-        line_processor=log_utils.SkyLocalUpLineProcessor(),
-        cwd=cwd)
-
-    # Kind always writes to stderr even if it succeeds.
-    # If the failure happens after the cluster is created, we need
-    # to strip all stderr of "No kind clusters found.", which is
-    # printed when querying with kind get clusters.
-    stderr = stderr.replace('No kind clusters found.\n', '')
-
-    if returncode == 0:
-        cluster_created = True
-    elif returncode == 100:
-        click.echo(f'{colorama.Fore.GREEN}Local cluster already '
-                   f'exists.{style.RESET_ALL}\n'
-                   'If you want to delete it instead, run: sky local down')
-    else:
-        with ux_utils.print_exception_no_traceback():
-            raise RuntimeError(
-                'Failed to create local cluster. '
-                f'Full log: {log_path}'
-                f'\nError: {style.BRIGHT}{stderr}{style.RESET_ALL}')
-    # Run sky check
-    with rich_utils.safe_status('[bold cyan]Running sky check...'):
-        sky_check.check(clouds=['kubernetes'], quiet=True)
-    if cluster_created:
-        # Prepare completion message which shows CPU and GPU count
-        # Get number of CPUs
-        p = subprocess_utils.run(
-            'kubectl get nodes -o jsonpath=\'{.items[0].status.capacity.cpu}\'',
-            capture_output=True)
-        num_cpus = int(p.stdout.decode('utf-8'))
-
-        # GPU count/type parsing
-        gpu_message = ''
-        gpu_hint = ''
-        if gpus:
-            # Get GPU model by querying the node labels
-            label_name_escaped = 'skypilot.co/accelerator'.replace('.', '\\.')
-            gpu_type_cmd = f'kubectl get node skypilot-control-plane -o jsonpath=\"{{.metadata.labels[\'{label_name_escaped}\']}}\"'  # pylint: disable=line-too-long
-            try:
-                # Run the command and capture the output
-                gpu_count_output = subprocess.check_output(gpu_type_cmd,
-                                                           shell=True,
-                                                           text=True)
-                gpu_type_str = gpu_count_output.strip() + ' '
-            except subprocess.CalledProcessError as e:
-                output = str(e.output.decode('utf-8'))
-                logger.warning(f'Failed to get GPU type: {output}')
-                gpu_type_str = ''
-
-            # Get number of GPUs (sum of nvidia.com/gpu resources)
-            gpu_count_command = 'kubectl get nodes -o=jsonpath=\'{range .items[*]}{.status.allocatable.nvidia\\.com/gpu}{\"\\n\"}{end}\' | awk \'{sum += $1} END {print sum}\''  # pylint: disable=line-too-long
-            try:
-                # Run the command and capture the output
-                gpu_count_output = subprocess.check_output(gpu_count_command,
-                                                           shell=True,
-                                                           text=True)
-                gpu_count = gpu_count_output.strip(
-                )  # Remove any extra whitespace
-                gpu_message = f' and {gpu_count} {gpu_type_str}GPUs'
-            except subprocess.CalledProcessError as e:
-                output = str(e.output.decode('utf-8'))
-                logger.warning(f'Failed to get GPU count: {output}')
-                gpu_message = f' with {gpu_type_str}GPU support'
-
-            gpu_hint = (
-                '\nHint: To see the list of GPUs in the cluster, '
-                'run \'sky show-gpus --cloud kubernetes\'') if gpus else ''
-
-        if num_cpus < 2:
-            click.echo('Warning: Local cluster has less than 2 CPUs. '
-                       'This may cause issues with running tasks.')
-        click.echo(
-            f'\n{colorama.Fore.GREEN}Local Kubernetes cluster created '
-            'successfully with '
-            f'{num_cpus} CPUs{gpu_message}.{style.RESET_ALL}\n`sky launch` can '
-            'now run tasks locally.'
-            '\nHint: To change the number of CPUs, change your docker '
-            'runtime settings. See https://kind.sigs.k8s.io/docs/user/quick-start/#settings-for-docker-desktop for more info.'  # pylint: disable=line-too-long
-            f'{gpu_hint}')
+def local_up(gpus: bool, ips: str, ssh_user: str, ssh_key_path: str,
+             cleanup: bool, async_call: bool):
+    """Creates a local or remote cluster."""
+
+    def _validate_args(ips, ssh_user, ssh_key_path, cleanup):
+        # If any of --ips, --ssh-user, or --ssh-key-path is specified,
+        # all must be specified
+        if bool(ips) or bool(ssh_user) or bool(ssh_key_path):
+            if not (ips and ssh_user and ssh_key_path):
+                raise click.BadParameter(
+                    'All --ips, --ssh-user, and --ssh-key-path '
+                    'must be specified together.')
+
+        # --cleanup can only be used if --ips, --ssh-user and --ssh-key-path
+        # are all provided
+        if cleanup and not (ips and ssh_user and ssh_key_path):
+            raise click.BadParameter('--cleanup can only be used with '
+                                     '--ips, --ssh-user and --ssh-key-path.')
+
+    _validate_args(ips, ssh_user, ssh_key_path, cleanup)
+
+    # If remote deployment arguments are specified, run remote up script
+    ip_list = None
+    ssh_key = None
+    if ips and ssh_user and ssh_key_path:
+        # Read and validate IP file
+        try:
+            with open(os.path.expanduser(ips), 'r', encoding='utf-8') as f:
+                ip_list = f.read().strip().splitlines()
+            if not ip_list:
+                raise click.BadParameter(f'IP file is empty: {ips}')
+        except (IOError, OSError) as e:
+            raise click.BadParameter(f'Failed to read IP file {ips}: {str(e)}')
+
+        # Read and validate SSH key file
+        try:
+            with open(os.path.expanduser(ssh_key_path), 'r',
+                      encoding='utf-8') as f:
+                ssh_key = f.read()
+            if not ssh_key:
+                raise click.BadParameter(
+                    f'SSH key file is empty: {ssh_key_path}')
+        except (IOError, OSError) as e:
+            raise click.BadParameter(
+                f'Failed to read SSH key file {ssh_key_path}: {str(e)}')
+
+    request_id = sdk.local_up(gpus, ip_list, ssh_user, ssh_key, cleanup)
+    _async_call_or_wait(request_id, async_call, request_name='local up')
 
 
 @local.command('down', cls=_DocumentedCodeCommand)
+@_add_click_options(_COMMON_OPTIONS)
 @usage_lib.entrypoint
-def local_down():
+def local_down(async_call: bool):
     """Deletes a local cluster."""
-    cluster_removed = False
+    request_id = sdk.local_down()
+    _async_call_or_wait(request_id, async_call, request_name='sky.local.down')
 
-    path_to_package = os.path.dirname(os.path.dirname(__file__))
-    down_script_path = os.path.join(path_to_package, 'sky/utils/kubernetes',
-                                    'delete_cluster.sh')
 
-    cwd = os.path.dirname(os.path.abspath(down_script_path))
-    run_command = shlex.split(down_script_path)
+@cli.group(cls=_NaturalOrderGroup)
+def api():
+    """SkyPilot API server commands."""
+    pass
 
-    # Setup logging paths
-    run_timestamp = backend_utils.get_run_timestamp()
-    log_path = os.path.join(constants.SKY_LOGS_DIRECTORY, run_timestamp,
-                            'local_down.log')
-    tail_cmd = 'tail -n100 -f ' + log_path
 
-    with rich_utils.safe_status('[bold cyan]Removing local cluster...'):
-        style = colorama.Style
-        click.echo('To view detailed progress: '
-                   f'{style.BRIGHT}{tail_cmd}{style.RESET_ALL}')
-        returncode, stdout, stderr = log_lib.run_with_log(cmd=run_command,
-                                                          log_path=log_path,
-                                                          require_outputs=True,
-                                                          stream_logs=False,
-                                                          cwd=cwd)
-        stderr = stderr.replace('No kind clusters found.\n', '')
-
-        if returncode == 0:
-            cluster_removed = True
-        elif returncode == 100:
-            click.echo('\nLocal cluster does not exist.')
-        else:
-            with ux_utils.print_exception_no_traceback():
-                raise RuntimeError(
-                    'Failed to create local cluster. '
-                    f'Stdout: {stdout}'
-                    f'\nError: {style.BRIGHT}{stderr}{style.RESET_ALL}')
-    if cluster_removed:
-        # Run sky check
-        with rich_utils.safe_status('[bold cyan]Running sky check...'):
-            sky_check.check(clouds=['kubernetes'], quiet=True)
-        click.echo(
-            f'{colorama.Fore.GREEN}Local cluster removed.{style.RESET_ALL}')
+@api.command('start', cls=_DocumentedCodeCommand)
+@click.option('--deploy',
+              type=bool,
+              is_flag=True,
+              default=False,
+              required=False,
+              help=('Deploy the SkyPilot API server. When set to True, '
+                    'SkyPilot API server will use all resources on the host '
+                    'machine assuming the machine is dedicated to SkyPilot API '
+                    'server; host will also be set to 0.0.0.0 to allow remote '
+                    'access.'))
+@click.option('--host',
+              default='127.0.0.1',
+              type=click.Choice(server_common.AVAILBLE_LOCAL_API_SERVER_HOSTS),
+              required=False,
+              help=('The host to deploy the SkyPilot API server. To allow '
+                    'remote access, set this to 0.0.0.0'))
+@click.option('--foreground',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Run the SkyPilot API server in the foreground and output '
+              'its logs to stdout/stderr. Allowing external systems '
+              'to manage the process lifecycle and collect logs directly. '
+              'This is useful when the API server is managed by systems '
+              'like systemd and Kubernetes.')
+@usage_lib.entrypoint
+def api_start(deploy: bool, host: Optional[str], foreground: bool):
+    """Starts the SkyPilot API server locally."""
+    sdk.api_start(deploy=deploy, host=host, foreground=foreground)
+
+
+@api.command('stop', cls=_DocumentedCodeCommand)
+@usage_lib.entrypoint
+def api_stop():
+    """Stops the SkyPilot API server locally."""
+    sdk.api_stop()
+
+
+@api.command('logs', cls=_DocumentedCodeCommand)
+@click.argument('request_id', required=False, type=str)
+@click.option('--server-logs',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Stream the server logs.')
+@click.option('--log-path',
+              '-l',
+              required=False,
+              type=str,
+              help='The path to the log file to stream.')
+@click.option('--tail',
+              required=False,
+              type=int,
+              help=('Number of lines to show from the end of the logs. '
+                    '(default: None)'))
+@click.option('--follow/--no-follow',
+              is_flag=True,
+              default=True,
+              required=False,
+              help='Follow the logs.')
+@usage_lib.entrypoint
+def api_logs(request_id: Optional[str], server_logs: bool,
+             log_path: Optional[str], tail: Optional[int], follow: bool):
+    """Stream the logs of a request running on SkyPilot API server."""
+    if not server_logs and request_id is None and log_path is None:
+        # TODO(zhwu): get the latest request ID.
+        raise click.BadParameter('Please provide the request ID or log path.')
+    if server_logs:
+        sdk.api_server_logs(follow=follow, tail=tail)
+        return
+
+    if request_id is not None and log_path is not None:
+        raise click.BadParameter(
+            'Only one of request ID and log path can be provided.')
+    sdk.stream_and_get(request_id, log_path, tail)
+
+
+@api.command('cancel', cls=_DocumentedCodeCommand)
+@click.argument('request_ids', required=False, type=str, nargs=-1)
+@click.option('--all',
+              '-a',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Cancel all your requests.')
+@click.option('--all-users',
+              '-u',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Cancel all requests from all users.')
+@usage_lib.entrypoint
+# pylint: disable=redefined-builtin
+def api_cancel(request_ids: Optional[List[str]], all: bool, all_users: bool):
+    """Cancel a request running on SkyPilot API server."""
+    if all or all_users:
+        keyword = 'ALL USERS\'' if all_users else 'YOUR'
+        user_input = click.prompt(
+            f'This will cancel all {keyword} requests.\n'
+            f'To proceed, please type {colorama.Style.BRIGHT}'
+            f'\'cancel all requests\'{colorama.Style.RESET_ALL}',
+            type=str)
+        if user_input != 'cancel all requests':
+            raise click.Abort()
+    if all:
+        request_ids = None
+    cancelled_request_ids = sdk.get(
+        sdk.api_cancel(request_ids=request_ids, all_users=all_users))
+    if not cancelled_request_ids:
+        click.secho('No requests need to be cancelled.', fg='green')
+    elif len(cancelled_request_ids) == 1:
+        click.secho(f'Cancelled 1 request: {cancelled_request_ids[0]}',
+                    fg='green')
+    else:
+        click.secho(f'Cancelled {len(cancelled_request_ids)} requests.',
+                    fg='green')
+
+
+@api.command('status', cls=_DocumentedCodeCommand)
+@click.argument('request_ids', required=False, type=str, nargs=-1)
+@click.option('--all-status',
+              '-a',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Show requests of all statuses.')
+@click.option('--verbose',
+              '-v',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Show more details.')
+@usage_lib.entrypoint
+# pylint: disable=redefined-builtin
+def api_status(request_ids: Optional[List[str]], all_status: bool,
+               verbose: bool):
+    """List requests on SkyPilot API server."""
+    if not request_ids:
+        request_ids = None
+    request_list = sdk.api_status(request_ids, all_status)
+    columns = ['ID', 'User', 'Name']
+    if verbose:
+        columns.append('Cluster')
+    columns.extend(['Created', 'Status'])
+    table = log_utils.create_table(columns)
+    for request in request_list:
+        r_id = request.request_id
+        if not verbose:
+            r_id = common_utils.truncate_long_string(r_id, 36)
+        req_status = requests.RequestStatus(request.status)
+        row = [r_id, request.user_name, request.name]
+        if verbose:
+            row.append(request.cluster_name)
+        row.extend([
+            log_utils.readable_time_duration(request.created_at),
+            req_status.colored_str()
+        ])
+        table.add_row(row)
+    click.echo(table)
+
+
+@api.command('login', cls=_DocumentedCodeCommand)
+@click.option('--endpoint',
+              '-e',
+              required=False,
+              help='The SkyPilot API server endpoint.')
+@usage_lib.entrypoint
+def api_login(endpoint: Optional[str]):
+    """Logs into a SkyPilot API server."""
+    sdk.api_login(endpoint)
+
+
+@api.command('info', cls=_DocumentedCodeCommand)
+@usage_lib.entrypoint
+def api_info():
+    """Shows the SkyPilot API server URL."""
+    url = server_common.get_server_url()
+    api_server_info = sdk.api_info()
+    user_name = os.getenv(constants.USER_ENV_VAR, getpass.getuser())
+    user_hash = common_utils.get_user_hash()
+    click.echo(f'Using SkyPilot API server: {url}\n'
+               f'{ux_utils.INDENT_SYMBOL}Status: {api_server_info["status"]}, '
+               f'commit: {api_server_info["commit"]}, '
+               f'version: {api_server_info["version"]}\n'
+               f'{ux_utils.INDENT_LAST_SYMBOL}User: {user_name} ({user_hash})')
 
 
 def main():