skypilot-nightly 1.0.0.dev20250528__py3-none-any.whl → 1.0.0.dev20250530__py3-none-any.whl

sky/serve/controller.py

@@ -42,12 +42,13 @@ class SkyServeController:
     """
 
     def __init__(self, service_name: str, service_spec: serve.SkyServiceSpec,
-                 task_yaml: str, host: str, port: int) -> None:
+                 service_task_yaml: str, host: str, port: int) -> None:
         self._service_name = service_name
         self._replica_manager: replica_managers.ReplicaManager = (
-            replica_managers.SkyPilotReplicaManager(service_name=service_name,
-                                                    spec=service_spec,
-                                                    task_yaml_path=task_yaml))
+            replica_managers.SkyPilotReplicaManager(
+                service_name=service_name,
+                spec=service_spec,
+                service_task_yaml_path=service_task_yaml))
         self._autoscaler: autoscalers.Autoscaler = (
             autoscalers.Autoscaler.from_spec(service_name, service_spec))
         self._host = host
@@ -240,7 +241,9 @@ class SkyServeController:
 # TODO(tian): Probably we should support service that will stop the VM in
 # specific time period.
 def run_controller(service_name: str, service_spec: serve.SkyServiceSpec,
-                   task_yaml: str, controller_host: str, controller_port: int):
-    controller = SkyServeController(service_name, service_spec, task_yaml,
-                                    controller_host, controller_port)
+                   service_task_yaml: str, controller_host: str,
+                   controller_port: int):
+    controller = SkyServeController(service_name, service_spec,
+                                    service_task_yaml, controller_host,
+                                    controller_port)
     controller.run()

sky/serve/replica_managers.py

@@ -58,7 +58,7 @@ _MAX_NUM_LAUNCH = psutil.cpu_count() * 2
 # TODO(tian): Combine this with
 # sky/spot/recovery_strategy.py::StrategyExecutor::launch
 def launch_cluster(replica_id: int,
-                   task_yaml_path: str,
+                   service_task_yaml_path: str,
                    cluster_name: str,
                    resources_override: Optional[Dict[str, Any]] = None,
                    retry_until_up: bool = True,
@@ -78,7 +78,8 @@ def launch_cluster(replica_id: int,
                     f'{cluster_name} with resources override: '
                     f'{resources_override}')
     try:
-        config = common_utils.read_yaml(os.path.expanduser(task_yaml_path))
+        config = common_utils.read_yaml(
+            os.path.expanduser(service_task_yaml_path))
         task = sky.Task.from_yaml_config(config)
         if resources_override is not None:
             resources = task.resources
@@ -173,9 +174,9 @@ def terminate_cluster(cluster_name: str,
             time.sleep(gap_seconds)
 
 
-def _get_resources_ports(task_yaml: str) -> str:
+def _get_resources_ports(service_task_yaml_path: str) -> str:
     """Get the resources ports used by the task."""
-    task = sky.Task.from_yaml(task_yaml)
+    task = sky.Task.from_yaml(service_task_yaml_path)
     # Already checked all ports are valid in sky.serve.core.up
     assert task.resources, task
     assert task.service is not None, task
@@ -183,7 +184,7 @@ def _get_resources_ports(task_yaml: str) -> str:
     return task.service.ports
 
 
-def _should_use_spot(task_yaml: str,
+def _should_use_spot(service_task_yaml_path: str,
                      resource_override: Optional[Dict[str, Any]]) -> bool:
     """Get whether the task should use spot."""
     if resource_override is not None:
@@ -191,7 +192,7 @@ def _should_use_spot(task_yaml: str,
         if use_spot_override is not None:
             assert isinstance(use_spot_override, bool)
             return use_spot_override
-    task = sky.Task.from_yaml(task_yaml)
+    task = sky.Task.from_yaml(service_task_yaml_path)
     spot_use_resources = [
         resources for resources in task.resources if resources.use_spot
     ]
@@ -634,10 +635,10 @@ class SkyPilotReplicaManager(ReplicaManager):
     """
 
     def __init__(self, service_name: str, spec: 'service_spec.SkyServiceSpec',
-                 task_yaml_path: str) -> None:
+                 service_task_yaml_path: str) -> None:
         super().__init__(service_name, spec)
-        self._task_yaml_path = task_yaml_path
-        task = sky.Task.from_yaml(task_yaml_path)
+        self.service_task_yaml_path = service_task_yaml_path
+        task = sky.Task.from_yaml(service_task_yaml_path)
         self._spot_placer: Optional[spot_placer.SpotPlacer] = (
             spot_placer.SpotPlacer.from_task(spec, task))
         # TODO(tian): Store launch/down pid in the replica table, to make the
@@ -714,7 +715,8 @@ class SkyPilotReplicaManager(ReplicaManager):
             self._service_name, replica_id)
         log_file_name = serve_utils.generate_replica_launch_log_file_name(
             self._service_name, replica_id)
-        use_spot = _should_use_spot(self._task_yaml_path, resources_override)
+        use_spot = _should_use_spot(self.service_task_yaml_path,
+                                    resources_override)
         retry_until_up = True
         location = None
         if use_spot and self._spot_placer is not None:
@@ -742,10 +744,10 @@ class SkyPilotReplicaManager(ReplicaManager):
                 launch_cluster,
                 log_file_name,
             ).run,
-            args=(replica_id, self._task_yaml_path, cluster_name,
+            args=(replica_id, self.service_task_yaml_path, cluster_name,
                   resources_override, retry_until_up),
         )
-        replica_port = _get_resources_ports(self._task_yaml_path)
+        replica_port = _get_resources_ports(self.service_task_yaml_path)
 
         info = ReplicaInfo(replica_id, cluster_name, replica_port, use_spot,
                            location, self.latest_version, resources_override)
@@ -1290,11 +1292,11 @@ class SkyPilotReplicaManager(ReplicaManager):
             logger.error(f'Invalid version: {version}, '
                          f'latest version: {self.latest_version}')
             return
-        task_yaml_path = serve_utils.generate_task_yaml_file_name(
+        service_task_yaml_path = serve_utils.generate_task_yaml_file_name(
             self._service_name, version)
         serve_state.add_or_update_version(self._service_name, version, spec)
         self.latest_version = version
-        self._task_yaml_path = task_yaml_path
+        self.service_task_yaml_path = service_task_yaml_path
         self._update_mode = update_mode
 
         # Reuse all replicas that have the same config as the new version
@@ -1302,7 +1304,8 @@ class SkyPilotReplicaManager(ReplicaManager):
         # the latest version. This can significantly improve the speed
         # for updating an existing service with only config changes to the
         # service specs, e.g. scale down the service.
-        new_config = common_utils.read_yaml(os.path.expanduser(task_yaml_path))
+        new_config = common_utils.read_yaml(
+            os.path.expanduser(service_task_yaml_path))
         # Always create new replicas and scale down old ones when file_mounts
         # are not empty.
         if new_config.get('file_mounts', None) != {}:
@@ -1313,10 +1316,11 @@ class SkyPilotReplicaManager(ReplicaManager):
         for info in replica_infos:
             if info.version < version and not info.is_terminal:
                 # Assume user does not change the yaml file on the controller.
-                old_task_yaml_path = serve_utils.generate_task_yaml_file_name(
-                    self._service_name, info.version)
+                old_service_task_yaml_path = (
+                    serve_utils.generate_task_yaml_file_name(
+                        self._service_name, info.version))
                 old_config = common_utils.read_yaml(
-                    os.path.expanduser(old_task_yaml_path))
+                    os.path.expanduser(old_service_task_yaml_path))
                 for key in ['service']:
                     old_config.pop(key)
                 # Bump replica version if all fields except for service are

sky/serve/service.py

@@ -186,7 +186,8 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
 
     service_dir = os.path.expanduser(
         serve_utils.generate_remote_service_dir_name(service_name))
-    task_yaml = serve_utils.generate_task_yaml_file_name(service_name, version)
+    service_task_yaml = serve_utils.generate_task_yaml_file_name(
+        service_name, version)
 
     if not is_recovery:
         if (len(serve_state.get_services()) >=
@@ -218,7 +219,7 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
         # don't want the new file mounts to overwrite the old one, so we
         # sync to a tmp file first and then copy it to the final name
         # if there is no name conflict.
-        shutil.copy(tmp_task_yaml, task_yaml)
+        shutil.copy(tmp_task_yaml, service_task_yaml)
 
     controller_process = None
     load_balancer_process = None
@@ -249,8 +250,8 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
             controller_host = _get_controller_host()
             controller_process = multiprocessing.Process(
                 target=controller.run_controller,
-                args=(service_name, service_spec, task_yaml, controller_host,
-                      controller_port))
+                args=(service_name, service_spec, service_task_yaml,
+                      controller_host, controller_port))
             controller_process.start()
 
             if not is_recovery:

sky/server/common.py

@@ -159,7 +159,8 @@ def get_server_url(host: Optional[str] = None) -> str:
 
 
 @annotations.lru_cache(scope='global')
-def get_dashboard_url(server_url: str) -> str:
+def get_dashboard_url(server_url: str,
+                      starting_page: Optional[str] = None) -> str:
     # The server_url may include username or password with the
     # format of https://username:password@example.com:8080/path
     # We need to remove the username and password and only
@@ -172,7 +173,10 @@ def get_dashboard_url(server_url: str) -> str:
     if parsed.path:
         dashboard_url = f'{dashboard_url}{parsed.path}'
     dashboard_url = dashboard_url.rstrip('/')
-    return f'{dashboard_url}/dashboard'
+    dashboard_url = f'{dashboard_url}/dashboard'
+    if starting_page:
+        dashboard_url = f'{dashboard_url}/{starting_page}'
+    return dashboard_url
 
 
 @annotations.lru_cache(scope='global')
@@ -529,10 +533,13 @@ def check_server_healthy_or_start_fn(deploy: bool = False,
     api_server_status = None
     try:
         api_server_status = check_server_healthy()
+        if api_server_status == ApiServerStatus.NEEDS_AUTH:
+            endpoint = get_server_url()
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.ApiServerAuthenticationError(endpoint)
     except exceptions.ApiServerConnectionError as exc:
         endpoint = get_server_url()
-        if (not is_api_server_local() or
-                api_server_status == ApiServerStatus.NEEDS_AUTH):
+        if not is_api_server_local():
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.ApiServerConnectionError(endpoint) from exc
         # Lock to prevent multiple processes from starting the server at the

sky/server/html/token_page.html

@@ -100,6 +100,9 @@
             color: #5f6368;
             margin-top: 30px;
         }
+        .local-port-info {
+            display: none;
+        }
     </style>
 </head>
 <body>
@@ -114,14 +117,18 @@
                 <path d="M16.632 21.3918L15.2651 27.6605L21.3357 25.6091L30.3276 16.6172L16.632 21.3918Z" fill="#39A4DD"/>
             </svg>
         </div>
-        <h1>Sign in to SkyPilot CLI</h1>
+        <h1 class="no-local-port">Sign in to SkyPilot CLI</h1>
+        <h1 class="local-port-info">Successfully signed into SkyPilot CLI</h1>
         <p class="user-identifier">USER_PLACEHOLDER</p>
-        <p>You are seeing this page because a SkyPilot command requires authentication.</p>
-        <p>Please copy the following token and paste it into your SkyPilot CLI prompt:</p>
-        <div id="token-box" class="code-block">SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER</div>
-        <button id="copy-btn" class="copy-button">Copy Token</button>
+        <!-- display token info by default -->
+        <p class="no-local-port">You are seeing this page because a SkyPilot command requires authentication.</p>
+        <p class="no-local-port">Please copy the following token and paste it into your SkyPilot CLI prompt:</p>
+        <div id="token-box" class="code-block no-local-port">SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER</div>
+        <button id="copy-btn" class="copy-button no-local-port">Copy Token</button>
+        <p class="footer-text no-local-port">You can close this tab after copying the token.</p>
 
-        <p class="footer-text">You can close this tab after copying the token.</p>
+        <!-- don't display local port info unless successful -->
+        <p class="local-port-info">You can now close this tab.</p>
     </div>
 
     <script>
@@ -154,6 +161,25 @@
                 copyBtn.textContent = 'Copy Token';
             }, 2000);
         });
+
+        function hideTokenInfo() {
+            const noLocalPortElems = document.querySelectorAll('.no-local-port');
+            noLocalPortElems.forEach(elem => {
+                elem.style.display = 'none';
+            });
+            const localPortInfoElems = document.querySelectorAll('.local-port-info');
+            localPortInfoElems.forEach(elem => {
+                elem.classList.remove('local-port-info');
+            });
+        }
+
+        if (window.location.search.includes('local_port=')) {
+            const uri = `http://localhost:${window.location.search.split('local_port=')[1]}`;
+            fetch(uri, {
+                method: 'POST',
+                body: 'SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER'
+            }).then(hideTokenInfo)
+        }
     </script>
 </body>
 </html>

sky/server/server.py

@@ -272,7 +272,9 @@ app.include_router(workspaces_rest.router,
 
 
 @app.get('/token')
-async def token(request: fastapi.Request) -> fastapi.responses.HTMLResponse:
+async def token(request: fastapi.Request,
+                local_port: Optional[int] = None) -> fastapi.responses.Response:
+    del local_port  # local_port is used by the served js, but ignored by server
     user = _get_auth_user_header(request)
 
     token_data = {

sky/server/stream_utils.py

@@ -15,6 +15,8 @@ from sky.utils import rich_utils
 
 logger = sky_logging.init_logger(__name__)
 
+_HEARTBEAT_INTERVAL = 30
+
 
 async def _yield_log_file_with_payloads_skipped(
         log_file) -> AsyncGenerator[str, None]:
@@ -90,6 +92,8 @@ async def log_streamer(request_id: Optional[str],
             for line_str in lines:
                 yield line_str
 
+        last_heartbeat_time = asyncio.get_event_loop().time()
+
         while True:
             # Sleep 0 to yield control to allow other coroutines to run,
             # while keeps the loop tight to make log stream responsive.
@@ -106,15 +110,32 @@ async def log_streamer(request_id: Optional[str],
                         break
                 if not follow:
                     break
+
+                current_time = asyncio.get_event_loop().time()
+                if current_time - last_heartbeat_time >= _HEARTBEAT_INTERVAL:
+                    # Currently just used to keep the connection busy, refer to
+                    # https://github.com/skypilot-org/skypilot/issues/5750 for
+                    # more details.
+                    yield message_utils.encode_payload(
+                        rich_utils.Control.HEARTBEAT.encode(''))
+                    last_heartbeat_time = current_time
+
                 # Sleep shortly to avoid storming the DB and CPU, this has
                 # little impact on the responsivness here since we are waiting
                 # for a new line to come in.
                 await asyncio.sleep(0.1)
                 continue
+
+            # Refresh the heartbeat time, this is a trivial optimization for
+            # performance but it helps avoid unnecessary heartbeat strings
+            # being printed when the client runs in an old version.
+            last_heartbeat_time = asyncio.get_event_loop().time()
             line_str = line.decode('utf-8')
             if plain_logs:
                 is_payload, line_str = message_utils.decode_payload(
                     line_str, raise_for_mismatch=False)
+                # TODO(aylei): implement heartbeat mechanism for plain logs,
+                # sending invisible characters might be okay.
                 if is_payload:
                     continue
             yield line_str

sky/setup_files/dependencies.py

@@ -118,7 +118,13 @@ extras_require: Dict[str, List[str]] = {
     # We need google-api-python-client>=2.69.0 to enable 'discardLocalSsd'
     # parameter for stopping instances. Reference:
     # https://github.com/googleapis/google-api-python-client/commit/f6e9d3869ed605b06f7cbf2e8cf2db25108506e6
-    'gcp': ['google-api-python-client>=2.69.0', 'google-cloud-storage'],
+    'gcp': [
+        'google-api-python-client>=2.69.0',
+        'google-cloud-storage',
+        # see https://github.com/conda/conda/issues/13619
+        # see https://github.com/googleapis/google-api-python-client/issues/2554
+        'pyopenssl >= 23.2.0, <24.3.0',
+    ],
     'ibm': [
         'ibm-cloud-sdk-core',
         'ibm-vpc',

sky/skylet/constants.py

@@ -89,7 +89,7 @@ TASK_ID_LIST_ENV_VAR = f'{SKYPILOT_ENV_VAR_PREFIX}TASK_IDS'
 # cluster yaml is updated.
 #
 # TODO(zongheng,zhanghao): make the upgrading of skylet automatic?
-SKYLET_VERSION = '12'
+SKYLET_VERSION = '13'
 # The version of the lib files that skylet/jobs use. Whenever there is an API
 # change for the job_lib or log_lib, we need to bump this version, so that the
 # user can be notified to update their SkyPilot version on the remote cluster.

sky/task.py

@@ -292,6 +292,8 @@ class Task:
         self.resources: Union[List[sky.Resources],
                               Set[sky.Resources]] = {sky.Resources()}
         self._service: Optional[service_spec.SkyServiceSpec] = None
+        # The priority of the managed job running this task.
+        self._job_priority: Optional[int] = None
         # Resources that this task cannot run on.
         self.blocked_resources = blocked_resources
 
@@ -629,6 +631,10 @@ class Task:
             service = service_spec.SkyServiceSpec.from_yaml_config(service)
         task.set_service(service)
 
+        job = config.pop('job', None)
+        if job is not None and 'priority' in job:
+            task.set_job_priority(job['priority'])
+
         assert not config, f'Invalid task args: {config.keys()}'
         return task
 
@@ -831,6 +837,23 @@ class Task:
         self._service = service
         return self
 
+    @property
+    def job_priority(self) -> Optional[int]:
+        """The priority of the managed job running this task."""
+        return self._job_priority
+
+    def set_job_priority(self, priority: int) -> 'Task':
+        """Sets the job priority for this task.
+
+        Args:
+          priority: an integer between 0 and 1000.
+
+        Returns:
+          self: The current task, with job priority set.
+        """
+        self._job_priority = priority
+        return self
+
     def set_time_estimator(self, func: Callable[['sky.Resources'],
                                                 int]) -> 'Task':
         """Sets a func mapping resources to estimated time (secs).
@@ -1274,6 +1297,9 @@ class Task:
         if self.service is not None:
             add_if_not_none('service', self.service.to_yaml_config())
 
+        if self.job_priority is not None:
+            add_if_not_none('job', {'priority': self.job_priority})
+
         add_if_not_none('num_nodes', self.num_nodes)
 
         if self.inputs is not None:

sky/templates/jobs-controller.yaml.j2

@@ -66,7 +66,8 @@ run: |
   # managed_job_codegen.set_pending() before we get here.
   python -u -m sky.jobs.scheduler {{remote_user_yaml_path}} \
     --job-id $SKYPILOT_INTERNAL_JOB_ID \
-    --env-file {{remote_env_file_path}}
+    --env-file {{remote_env_file_path}} \
+    --priority {{priority}}
 
 
 envs:

sky/templates/kubernetes-ray.yml.j2

@@ -395,6 +395,13 @@ available_node_types:
               # STEP 1: Run apt update, install missing packages, and set up ssh.
               (
                 (
+                # For backwards compatibility, we put a marker file in the pod
+                # to indicate that the apt ssh setup step will write a completion
+                # marker file (/tmp/apt_ssh_setup_complete) to the pod.
+                # TODO: Remove this marker file and its usage in setup_commands
+                # after v0.11.0 release.
+                touch /tmp/apt_ssh_setup_started
+
                 DEBIAN_FRONTEND=noninteractive $(prefix_cmd) apt-get update > /tmp/apt-update.log 2>&1 || \
                 echo "Warning: apt-get update failed. Continuing anyway..." >> /tmp/apt-update.log
                 # Install both fuse2 and fuse3 for compatibility for all possible fuse adapters in advance,
@@ -402,7 +409,7 @@ available_node_types:
                 PACKAGES="rsync curl wget netcat gcc patch pciutils fuse fuse3 openssh-server";
 
                 # Separate packages into two groups: packages that are installed first
-                # so that curl, rsync and wget are available sooner to unblock the following
+                # so that curl, rsync, ssh and wget are available sooner to unblock the following
                 # conda installation and rsync.
                 # Also, we install fuse first to avoid confliction with fuse3.
                 set -e
@@ -494,6 +501,8 @@ available_node_types:
                 $(prefix_cmd) service ssh restart;
                 $(prefix_cmd) sed -i "s/mesg n/tty -s \&\& mesg n/" ~/.profile;
 
+                touch /tmp/apt_ssh_setup_complete
+                echo "=== SSH setup completed ==="
                 ) > /tmp/${STEPS[0]}.log 2>&1 || {
                   echo "Error: ${STEPS[0]} failed. Continuing anyway..." > /tmp/${STEPS[0]}.failed
                   cat /tmp/${STEPS[0]}.log
@@ -791,6 +800,15 @@ setup_commands:
     {%- endfor %}
     STEPS=("apt-ssh-setup" "runtime-setup" "env-setup")
     start_epoch=$(date +%s);
+    
+    # Wait for SSH setup to complete before proceeding
+    if [ -f /tmp/apt_ssh_setup_started ]; then
+      echo "=== Logs for asynchronous SSH setup ===";
+      [ -f /tmp/apt_ssh_setup_complete ] && cat /tmp/${STEPS[0]}.log ||
+      { tail -f -n +1 /tmp/${STEPS[0]}.log & TAIL_PID=$!; echo "Tail PID: $TAIL_PID"; until [ -f /tmp/apt_ssh_setup_complete ]; do sleep 0.5; done; kill $TAIL_PID || true; };
+      [ -f /tmp/${STEPS[0]}.failed ] && { echo "Error: ${STEPS[0]} failed. Exiting."; exit 1; } || true;
+    fi
+    
     echo "=== Logs for asynchronous ray and skypilot installation ===";
     if [ -f /tmp/skypilot_is_nimbus ]; then
       echo "=== Logs for asynchronous ray and skypilot installation ===";

sky/utils/common_utils.py

@@ -324,9 +324,75 @@ def get_pretty_entrypoint_cmd() -> str:
         # Turn '/.../anaconda/envs/py36/bin/sky' into 'sky', but keep other
         # things like 'examples/app.py'.
         argv[0] = basename
+
+    # Redact sensitive environment variable values
+    argv = _redact_env_values(argv)
+
     return ' '.join(argv)
 
 
+def _redact_env_values(argv: List[str]) -> List[str]:
+    """Redact sensitive values from --env arguments.
+
+    Args:
+        argv: Command line arguments
+
+    Returns:
+        Modified argv with redacted --env values, or original argv if any error
+
+    Examples:
+        ['sky', 'launch', '--env', 'HF_TOKEN=secret'] ->
+        ['sky', 'launch', '--env', 'HF_TOKEN=<redacted>']
+
+        ['sky', 'launch', '--env=HF_TOKEN=secret'] ->
+        ['sky', 'launch', '--env=HF_TOKEN=<redacted>']
+
+        ['sky', 'launch', '--env', 'HF_TOKEN'] ->
+        ['sky', 'launch', '--env', 'HF_TOKEN'] (no change)
+    """
+    try:
+        if not argv:
+            return argv or []
+
+        result = []
+        i = 0
+
+        while i < len(argv):
+            arg = argv[i]
+
+            # Ensure arg is a string
+            if not isinstance(arg, str):
+                result.append(arg)
+                i += 1
+                continue
+
+            if arg == '--env' and i + 1 < len(argv):
+                result.append(arg)
+                next_arg = argv[i + 1]
+                # Ensure next_arg is a string and handle redaction safely
+                if isinstance(next_arg, str):
+                    redacted = re.sub(r'^([^=]+)=.*', r'\1=<redacted>',
+                                      next_arg)
+                    result.append(redacted)
+                else:
+                    result.append(next_arg)
+                i += 2
+            elif arg.startswith('--env='):
+                # Redact only if there's a value after the key
+                redacted = re.sub(r'^(--env=[^=]+)=.*', r'\1=<redacted>', arg)
+                result.append(redacted)
+                i += 1
+            else:
+                result.append(arg)
+                i += 1
+
+        return result
+    except Exception:  # pylint: disable=broad-except
+        # If anything goes wrong with redaction, return original argv
+        # This ensures the command can still execute
+        return argv or []
+
+
 def user_and_hostname_hash() -> str:
     """Returns a string containing <user>-<hostname hash last 4 chars>.
 

sky/utils/rich_utils.py

@@ -57,6 +57,7 @@ class Control(enum.Enum):
     STOP = 'rich_stop'
     EXIT = 'rich_exit'
     UPDATE = 'rich_update'
+    HEARTBEAT = 'heartbeat'
 
     def encode(self, msg: str) -> str:
         return f'<{self.value}>{msg}</{self.value}>'
@@ -385,6 +386,10 @@ def decode_rich_status(
                         decoding_status.__exit__(None, None, None)
                     elif control == Control.START:
                         decoding_status.start()
+                    elif control == Control.HEARTBEAT:
+                        # Heartbeat is not displayed to the user, so we do not
+                        # need to update the status.
+                        pass
     finally:
         if decoding_status is not None:
             decoding_status.__exit__(None, None, None)

sky/utils/schemas.py

@@ -646,6 +646,18 @@ def get_task_schema():
             'service': {
                 'type': 'object',
             },
+            'job': {
+                'type': 'object',
+                'required': [],
+                'additionalProperties': False,
+                'properties': {
+                    'priority': {
+                        'type': 'integer',
+                        'minimum': 0,
+                        'maximum': 1000,
+                    },
+                },
+            },
             'setup': {
                 'type': 'string',
             },
@@ -1096,6 +1108,9 @@ def get_config_schema():
             'required': [],
             'properties': {
                 **_NETWORK_CONFIG_SCHEMA,
+                'tenant_id': {
+                    'type': 'string',
+                },
             },
             'additionalProperties': {
                 'type': 'object',
@@ -1200,7 +1215,7 @@ def get_config_schema():
     # all clouds except gcp, kubernetes, ssh
     not_supported_clouds = [
         cloud for cloud in allowed_workspace_cloud_names
-        if cloud.lower() not in ['gcp', 'kubernetes', 'ssh']
+        if cloud.lower() not in ['gcp', 'kubernetes', 'ssh', 'nebius']
     ]
     not_supported_cloud_regex = '|'.join(not_supported_clouds)
     workspaces_schema = {
@@ -1269,6 +1284,22 @@ def get_config_schema():
                     },
                     'additionalProperties': False,
                 },
+                'nebius': {
+                    'type': 'object',
+                    'required': [],
+                    'properties': {
+                        'credentials_file_path': {
+                            'type': 'string',
+                        },
+                        'tenant_id': {
+                            'type': 'string',
+                        },
+                        'disabled': {
+                            'type': 'boolean'
+                        },
+                    },
+                    'additionalProperties': False,
+                },
             },
         },
     }