skypilot-nightly 1.0.0.dev20250522__py3-none-any.whl → 1.0.0.dev20250524__py3-none-any.whl

sky/clouds/oci.py

@@ -401,13 +401,15 @@ class OCI(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         OCI's compute service."""
         return cls._check_credentials()
 
     @classmethod
-    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_storage_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         OCI's storage service."""
         # TODO(seungjin): Implement separate check for

sky/clouds/paperspace.py

@@ -255,7 +255,8 @@ class Paperspace(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         Paperspace's compute service."""
         try:

sky/clouds/runpod.py

@@ -259,7 +259,8 @@ class RunPod(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         RunPod's compute service."""
         return cls._check_credentials()

sky/clouds/scp.py

@@ -316,7 +316,8 @@ class SCP(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         SCP's compute service."""
         try:

sky/clouds/service_catalog/constants.py

@@ -5,4 +5,4 @@ CATALOG_SCHEMA_VERSION = 'v7'
 CATALOG_DIR = '~/.sky/catalogs'
 ALL_CLOUDS = ('aws', 'azure', 'gcp', 'ibm', 'lambda', 'scp', 'oci',
               'kubernetes', 'runpod', 'vast', 'vsphere', 'cudo', 'fluidstack',
-              'paperspace', 'do', 'nebius')
+              'paperspace', 'do', 'nebius', 'ssh')

sky/clouds/service_catalog/ssh_catalog.py

@@ -0,0 +1,167 @@
+"""SSH Catalog.
+
+This catalog inherits from the Kubernetes catalog as SSH cloud is a wrapper
+around Kubernetes that uses SSH-specific contexts.
+"""
+import typing
+from typing import Dict, List, Optional, Tuple
+
+from sky import sky_logging
+from sky.clouds import ssh
+from sky.clouds.service_catalog import CloudFilter
+from sky.clouds.service_catalog import common
+from sky.clouds.service_catalog import kubernetes_catalog
+
+logger = sky_logging.init_logger(__name__)
+
+if typing.TYPE_CHECKING:
+    import pandas as pd
+else:
+    from sky.adaptors import common as adaptors_common
+    pd = adaptors_common.LazyImport('pandas')
+
+_PULL_FREQUENCY_HOURS = 7
+
+# Reuse the Kubernetes images catalog for SSH cloud.
+# We keep pull_frequency_hours so we can remotely update the default image paths
+_image_df = common.read_catalog('kubernetes/images.csv',
+                                pull_frequency_hours=_PULL_FREQUENCY_HOURS)
+
+
+def get_image_id_from_tag(tag: str, region: Optional[str]) -> Optional[str]:
+    """Returns the image id from the tag.
+
+    Delegates to Kubernetes catalog implementation.
+    """
+    return kubernetes_catalog.get_image_id_from_tag(tag, region)
+
+
+def is_image_tag_valid(tag: str, region: Optional[str]) -> bool:
+    """Returns whether the image tag is valid.
+
+    Delegates to Kubernetes catalog implementation.
+    """
+    return kubernetes_catalog.is_image_tag_valid(tag, region)
+
+
+def list_accelerators(
+        gpus_only: bool,
+        name_filter: Optional[str],
+        region_filter: Optional[str],
+        quantity_filter: Optional[int],
+        case_sensitive: bool = True,
+        all_regions: bool = False,
+        require_price: bool = True) -> Dict[str, List[common.InstanceTypeInfo]]:
+    """List accelerators in SSH-based Kubernetes clusters.
+
+    Delegates to the Kubernetes _list_accelerators function but restricts to
+    SSH contexts.
+    """
+    return _list_accelerators(gpus_only,
+                              name_filter,
+                              region_filter,
+                              quantity_filter,
+                              case_sensitive,
+                              all_regions,
+                              require_price,
+                              realtime=False)[0]
+
+
+def list_accelerators_realtime(
+    gpus_only: bool,
+    name_filter: Optional[str],
+    region_filter: Optional[str],
+    quantity_filter: Optional[int],
+    case_sensitive: bool = True,
+    all_regions: bool = False,
+    require_price: bool = True
+) -> Tuple[Dict[str, List[common.InstanceTypeInfo]], Dict[str, int], Dict[str,
+                                                                          int]]:
+    """List accelerators in SSH Node Pools with real-time information.
+
+    Delegates to the Kubernetes _list_accelerators function but restricts to
+    SSH contexts.
+    """
+    return _list_accelerators(gpus_only,
+                              name_filter,
+                              region_filter,
+                              quantity_filter,
+                              case_sensitive,
+                              all_regions,
+                              require_price,
+                              realtime=True)
+
+
+def _list_accelerators(
+    gpus_only: bool,
+    name_filter: Optional[str],
+    region_filter: Optional[str],
+    quantity_filter: Optional[int],
+    case_sensitive: bool = True,
+    all_regions: bool = False,
+    require_price: bool = True,
+    realtime: bool = False
+) -> Tuple[Dict[str, List[common.InstanceTypeInfo]], Dict[str, int], Dict[str,
+                                                                          int]]:
+    """List accelerators in SSH-based Kubernetes clusters.
+
+    This is a wrapper around the Kubernetes _list_accelerators function that
+    restricts the contexts to SSH-specific contexts only.
+
+    If region_filter is specified and it's not an SSH context, no results will
+    be returned.
+    """
+    # If a specific region is requested, ensure it's an SSH context
+    if region_filter is not None and not region_filter.startswith('ssh-'):
+        return {}, {}, {}
+
+    # Get SSH contexts
+    ssh_contexts = ssh.SSH.existing_allowed_contexts()
+
+    # If no contexts found, return empty results
+    if not ssh_contexts:
+        return {}, {}, {}
+
+    # If a region filter is specified and it's not a SSH context return empty
+    # results
+    if region_filter is not None and region_filter not in ssh_contexts:
+        return {}, {}, {}
+
+    # If region_filter is None, use the first context if all_regions is False
+    if region_filter is None and not all_regions and ssh_contexts:
+        # Use the first SSH context if no specific region requested
+        region_filter = ssh_contexts[0]
+
+    # Call the Kubernetes _list_accelerators with the appropriate region filter
+    if realtime:
+        return kubernetes_catalog.list_accelerators_realtime(
+            gpus_only, name_filter, region_filter, quantity_filter,
+            case_sensitive, all_regions, require_price)
+    else:
+        result = kubernetes_catalog.list_accelerators(
+            gpus_only, name_filter, region_filter, quantity_filter,
+            case_sensitive, all_regions, require_price)
+        return result, {}, {}
+
+
+def validate_region_zone(
+        region_name: Optional[str],
+        zone_name: Optional[str],
+        clouds: CloudFilter = None) -> Tuple[Optional[str], Optional[str]]:
+    """Validates the region and zone for SSH cloud.
+
+    Delegates to the Kubernetes catalog implementation but ensures
+    the region is a valid SSH context.
+    """
+    # Delegate to Kubernetes implementation
+    region, zone = kubernetes_catalog.validate_region_zone(
+        region_name, zone_name, clouds)
+
+    # Get SSH contexts
+    ssh_contexts = ssh.SSH.existing_allowed_contexts()
+
+    # If a region is specified, ensure it's in the list of SSH contexts
+    if region is not None and region not in ssh_contexts:
+        return None, None
+
+    return region, zone

sky/clouds/ssh.py

@@ -0,0 +1,203 @@
+"""SSH Node Pools"""
+
+import os
+import typing
+from typing import Dict, List, Optional, Set, Tuple, Union
+
+import yaml
+
+from sky import sky_logging
+from sky.adaptors import kubernetes as kubernetes_adaptor
+from sky.clouds import kubernetes
+from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import annotations
+from sky.utils import registry
+
+if typing.TYPE_CHECKING:
+    # Renaming to avoid shadowing variables.
+    from sky import resources as resources_lib
+
+logger = sky_logging.init_logger(__name__)
+
+SSH_NODE_POOLS_PATH = os.path.expanduser('~/.sky/ssh_node_pools.yaml')
+
+
+@registry.CLOUD_REGISTRY.register()
+class SSH(kubernetes.Kubernetes):
+    """SSH cloud implementation.
+
+    This is used by SSH Node Pools in SkyPilot, which use Kubernetes to manage
+    the SSH clusters.
+
+    This cloud is a thin wrapper around Kubernetes that only uses contexts
+    starting with 'ssh-', which are managed through `sky ssh up` command.
+    """
+
+    _REPR = 'SSH'
+
+    # Keep track of contexts that have been logged as unreachable
+    logged_unreachable_contexts: Set[str] = set()
+
+    def __repr__(self):
+        return self._REPR
+
+    @classmethod
+    def _unsupported_features_for_resources(
+        cls, resources: 'resources_lib.Resources'
+    ) -> Dict[kubernetes.clouds.CloudImplementationFeatures, str]:
+        # Inherit all Kubernetes unsupported features
+        return super()._unsupported_features_for_resources(resources)
+
+    @classmethod
+    def get_ssh_node_pool_contexts(cls) -> List[str]:
+        """Get context names from ssh_node_pools.yaml file.
+
+        Reads the SSH node pools configuration file and returns
+        a list of context names by prepending 'ssh-' to each Node Pool name.
+
+        Returns:
+            A list of SSH Kubernetes context names derived from the Node Pools
+            in the SSH node pools file.
+        """
+        contexts = []
+
+        if os.path.exists(SSH_NODE_POOLS_PATH):
+            try:
+                with open(SSH_NODE_POOLS_PATH, 'r', encoding='utf-8') as f:
+                    ssh_config = yaml.safe_load(f)
+                    if ssh_config:
+                        # Get cluster names and prepend 'ssh-' to match
+                        # context naming convention
+                        contexts = [
+                            f'ssh-{cluster_name}'
+                            for cluster_name in ssh_config.keys()
+                        ]
+            except Exception:  # pylint: disable=broad-except
+                # If there's an error reading the file, return empty list
+                pass
+
+        return contexts
+
+    def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
+        if region == kubernetes_adaptor.in_cluster_context_name():
+            # If running incluster, we set region to IN_CLUSTER_REGION
+            # since there is no context name available.
+            return region, zone
+
+        all_contexts = self.existing_allowed_contexts()
+
+        if region is not None and region not in all_contexts:
+            region_name = region.lstrip('ssh-')
+            available_contexts = [c.lstrip('ssh-') for c in all_contexts]
+            err_str = (f'SSH Node Pool {region_name!r} is not set up. '
+                       'Run `sky check` for more details. ')
+            if available_contexts:
+                err_str += f'Available node pools: {available_contexts}'
+            raise ValueError(err_str)
+        if zone is not None:
+            raise ValueError('SSH Node Pools do not support setting zone.')
+        return region, zone
+
+    @classmethod
+    @annotations.lru_cache(scope='global', maxsize=1)
+    def _ssh_log_skipped_contexts_once(
+            cls, skipped_contexts: Tuple[str, ...]) -> None:
+        """Log skipped contexts for only once.
+
+        We don't directly cache the result of _filter_existing_allowed_contexts
+        as the admin policy may update the allowed contexts.
+        """
+        if skipped_contexts:
+            count = len(set(skipped_contexts))
+            is_singular = count == 1
+            logger.warning(
+                f'SSH Node {("Pool" if is_singular else "Pools")} '
+                f'{set(skipped_contexts)!r} specified in '
+                f'{SSH_NODE_POOLS_PATH} {("has" if is_singular else "have")} '
+                'not been set up. Skipping '
+                f'{("that pool" if is_singular else "those pools")}. '
+                'Run `sky ssh up` to set up.')
+
+    @classmethod
+    def existing_allowed_contexts(cls, silent: bool = False) -> List[str]:
+        """Get existing allowed contexts that start with 'ssh-'.
+
+        Override the Kubernetes implementation to only return contexts that
+        start with 'ssh-', which are created by `sky ssh up`.
+
+        Returns contexts based on clusters defined in ~/.sky/ssh_node_pools.yaml
+        """
+        # Get all contexts from the Kubernetes implementation
+        all_contexts = kubernetes_utils.get_all_kube_context_names()
+        if not all_contexts:
+            return []
+
+        all_contexts = set(all_contexts)
+
+        # Filter for SSH contexts (those starting with 'ssh-')
+        ssh_contexts = [
+            context for context in all_contexts if context.startswith('ssh-')
+        ]
+
+        # Get contexts from SSH node pools file
+        allowed_contexts = cls.get_ssh_node_pool_contexts()
+
+        if allowed_contexts:
+            # Only include allowed contexts that exist
+            existing_contexts = []
+            skipped_contexts = []
+            for context in allowed_contexts:
+                if context in ssh_contexts:
+                    existing_contexts.append(context)
+                else:
+                    skipped_contexts.append(context)
+            if not silent:
+                cls._ssh_log_skipped_contexts_once(tuple(skipped_contexts))
+            return existing_contexts
+
+        # If no allowed_contexts found, return all SSH contexts
+        return ssh_contexts
+
+    @classmethod
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
+        """Check if the user has access credentials to SSH contexts."""
+        # Check for port forward dependencies - reuse Kubernetes implementation
+        reasons = kubernetes_utils.check_port_forward_mode_dependencies(False)
+        if reasons is not None:
+            formatted = '\n'.join(
+                [reasons[0]] +
+                [f'{cls._INDENT_PREFIX}' + r for r in reasons[1:]])
+            return (False, formatted)
+
+        # Get SSH contexts
+        try:
+            existing_allowed_contexts = cls.existing_allowed_contexts()
+        except Exception as e:  # pylint: disable=broad-except
+            return (False, f'Failed to get SSH contexts: {str(e)}')
+
+        if not existing_allowed_contexts:
+            return (False,
+                    'No SSH Node Pools are up. Run `sky ssh up` to set up '
+                    f'Node Pools from {SSH_NODE_POOLS_PATH}.')
+
+        # Check credentials for each context
+        ctx2text = {}
+        success = False
+        for context in existing_allowed_contexts:
+            suc, text = super()._check_single_context(context)
+            success = success or suc
+            ctx2text[context] = text
+
+        return success, ctx2text
+
+    @classmethod
+    def get_infras(cls) -> List[str]:
+        return [
+            f'{cls._REPR.lower()}/{c.lstrip("ssh-")}'
+            for c in cls.existing_allowed_contexts(silent=True)
+        ]
+
+    @classmethod
+    def display_name(cls) -> str:
+        return 'SSH Node Pools'

sky/clouds/vast.py

@@ -237,7 +237,8 @@ class Vast(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has valid credentials for
         Vast's compute service. """
         try:

sky/clouds/vsphere.py

@@ -261,7 +261,8 @@ class Vsphere(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(
+            cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         vSphere's compute service."""
 

sky/core.py

@@ -17,6 +17,7 @@ from sky import global_user_state
 from sky import models
 from sky import optimizer
 from sky import sky_logging
+from sky import skypilot_config
 from sky import task as task_lib
 from sky.backends import backend_utils
 from sky.clouds import cloud as sky_cloud
@@ -470,7 +471,10 @@ def _stop_not_supported_message(resources: 'resources_lib.Resources') -> str:
         message = ('Stopping spot instances is currently not supported on '
                    f'{resources.cloud}')
     else:
-        message = f'Stopping is currently not supported for {resources}'
+        cloud_name = resources.cloud.display_name(
+        ) if resources.cloud else resources.cloud
+        message = ('Stopping is currently not supported for '
+                   f'{cloud_name}')
     return message
 
 
@@ -1006,20 +1010,31 @@ def storage_delete(name: str) -> None:
 # = Catalog Observe =
 # ===================
 @usage_lib.entrypoint
-def enabled_clouds() -> List[clouds.Cloud]:
+def enabled_clouds(workspace: Optional[str] = None) -> List[clouds.Cloud]:
+    if workspace is None:
+        workspace = skypilot_config.get_active_workspace()
     return global_user_state.get_cached_enabled_clouds(
-        sky_cloud.CloudCapability.COMPUTE)
+        sky_cloud.CloudCapability.COMPUTE, workspace=workspace)
 
 
 @usage_lib.entrypoint
 def realtime_kubernetes_gpu_availability(
     context: Optional[str] = None,
     name_filter: Optional[str] = None,
-    quantity_filter: Optional[int] = None
+    quantity_filter: Optional[int] = None,
+    is_ssh: Optional[bool] = None
 ) -> List[Tuple[str, List[models.RealtimeGpuAvailability]]]:
 
     if context is None:
-        context_list = clouds.Kubernetes.existing_allowed_contexts()
+        # Include contexts from both Kubernetes and SSH clouds
+        kubernetes_contexts = clouds.Kubernetes.existing_allowed_contexts()
+        ssh_contexts = clouds.SSH.existing_allowed_contexts()
+        if is_ssh is None:
+            context_list = kubernetes_contexts + ssh_contexts
+        elif is_ssh:
+            context_list = ssh_contexts
+        else:
+            context_list = kubernetes_contexts
     else:
         context_list = [context]
 
@@ -1030,7 +1045,7 @@ def realtime_kubernetes_gpu_availability(
     ) -> List[models.RealtimeGpuAvailability]:
         counts, capacity, available = service_catalog.list_accelerator_realtime(
             gpus_only=True,
-            clouds='kubernetes',
+            clouds='ssh' if is_ssh else 'kubernetes',
             name_filter=name_filter,
             region_filter=context,
             quantity_filter=quantity_filter,
@@ -1062,16 +1077,19 @@ def realtime_kubernetes_gpu_availability(
             name_filter=name_filter,
             quantity_filter=quantity_filter), context_list)
 
+    cloud_identity = 'ssh' if is_ssh else 'kubernetes'
+    cloud_identity_capital = 'SSH' if is_ssh else 'Kubernetes'
+
     for ctx, queried in zip(context_list, parallel_queried):
         cumulative_count += len(queried)
         if len(queried) == 0:
             # don't add gpu results for clusters that don't have any
-            logger.debug(f'No gpus found in k8s cluster {ctx}')
+            logger.debug(f'No gpus found in {cloud_identity} cluster {ctx}')
             continue
         availability_lists.append((ctx, queried))
 
     if cumulative_count == 0:
-        err_msg = 'No GPUs found in any Kubernetes clusters. '
+        err_msg = f'No GPUs found in any {cloud_identity_capital} clusters. '
         debug_msg = 'To further debug, run: sky check '
         if name_filter is not None:
             gpu_info_msg = f' {name_filter!r}'
@@ -1079,9 +1097,9 @@ def realtime_kubernetes_gpu_availability(
                 gpu_info_msg += (' with requested quantity'
                                  f' {quantity_filter}')
             err_msg = (f'Resources{gpu_info_msg} not found '
-                       'in Kubernetes clusters. ')
-            debug_msg = ('To show available accelerators on kubernetes,'
-                         ' run: sky show-gpus --cloud kubernetes ')
+                       f'in {cloud_identity_capital} clusters. ')
+            debug_msg = (f'To show available accelerators on {cloud_identity}, '
+                         f' run: sky show-gpus --cloud {cloud_identity} ')
         full_err_msg = (err_msg + kubernetes_constants.NO_GPU_HELP_MESSAGE +
                         debug_msg)
         raise ValueError(full_err_msg)
@@ -1179,3 +1197,32 @@ def local_down() -> None:
             ux_utils.finishing_message('Local cluster removed.',
                                        log_path=log_path,
                                        is_local=True))
+
+
+@usage_lib.entrypoint
+def ssh_up(infra: Optional[str] = None, cleanup: bool = False) -> None:
+    """Deploys or tears down a Kubernetes cluster on SSH targets.
+
+    Args:
+        infra: Name of the cluster configuration in ssh_node_pools.yaml.
+            If None, the first cluster in the file is used.
+        cleanup: If True, clean up the cluster instead of deploying.
+    """
+    kubernetes_deploy_utils.deploy_ssh_cluster(
+        cleanup=cleanup,
+        infra=infra,
+    )
+
+
+def get_all_contexts() -> List[str]:
+    """Get all available contexts from Kubernetes and SSH clouds.
+
+    Returns:
+        List[str]: A list of all available context names.
+    """
+    kube_contexts = clouds.Kubernetes.existing_allowed_contexts()
+    ssh_contexts = clouds.SSH.get_ssh_node_pool_contexts()
+    # Ensure ssh_contexts are prefixed appropriately if not already
+    # For now, assuming get_ssh_node_pool_contexts already returns them
+    # in the desired format (e.g., 'ssh-my-cluster')
+    return sorted(list(set(kube_contexts + ssh_contexts)))

sky/dashboard/out/404.html

@@ -1 +1 @@
-<!DOCTYPE html><html><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><title>404: This page could not be found</title><meta name="next-head-count" content="3"/><link rel="preload" href="/dashboard/_next/static/css/7e7ce4ff31d3977b.css" as="style"/><link rel="stylesheet" href="/dashboard/_next/static/css/7e7ce4ff31d3977b.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/dashboard/_next/static/chunks/polyfills-78c92fac7aa8fdd8.js"></script><script src="/dashboard/_next/static/chunks/webpack-830f59b8404e96b8.js" defer=""></script><script src="/dashboard/_next/static/chunks/framework-87d061ee6ed71b28.js" defer=""></script><script src="/dashboard/_next/static/chunks/main-e0e2335212e72357.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_app-8cfab319f9fb3ae8.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_error-1be831200e60c5c0.js" defer=""></script><script src="/dashboard/_next/static/CzOVV6JpRQBRt5GhZuhyK/_buildManifest.js" defer=""></script><script src="/dashboard/_next/static/CzOVV6JpRQBRt5GhZuhyK/_ssgManifest.js" defer=""></script></head><body><div id="__next"><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div style="line-height:48px"><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding-right:23px;font-size:24px;font-weight:500;vertical-align:top">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:28px">This page could not be found<!-- -->.</h2></div></div></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"statusCode":404}},"page":"/_error","query":{},"buildId":"CzOVV6JpRQBRt5GhZuhyK","assetPrefix":"/dashboard","nextExport":true,"isFallback":false,"gip":true,"scriptLoader":[]}</script></body></html>
+<!DOCTYPE html><html><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><title>404: This page could not be found</title><meta name="next-head-count" content="3"/><link rel="preload" href="/dashboard/_next/static/css/d2cdba64c9202dd7.css" as="style"/><link rel="stylesheet" href="/dashboard/_next/static/css/d2cdba64c9202dd7.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/dashboard/_next/static/chunks/polyfills-78c92fac7aa8fdd8.js"></script><script src="/dashboard/_next/static/chunks/webpack-deda68c926e8d0bc.js" defer=""></script><script src="/dashboard/_next/static/chunks/framework-87d061ee6ed71b28.js" defer=""></script><script src="/dashboard/_next/static/chunks/main-e0e2335212e72357.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_app-dec800f9ef1b10f4.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_error-1be831200e60c5c0.js" defer=""></script><script src="/dashboard/_next/static/aHej19bZyl4hoHgrzPCn7/_buildManifest.js" defer=""></script><script src="/dashboard/_next/static/aHej19bZyl4hoHgrzPCn7/_ssgManifest.js" defer=""></script></head><body><div id="__next"><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div style="line-height:48px"><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding-right:23px;font-size:24px;font-weight:500;vertical-align:top">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:28px">This page could not be found<!-- -->.</h2></div></div></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"statusCode":404}},"page":"/_error","query":{},"buildId":"aHej19bZyl4hoHgrzPCn7","assetPrefix":"/dashboard","nextExport":true,"isFallback":false,"gip":true,"scriptLoader":[]}</script></body></html>

sky/dashboard/out/_next/static/aHej19bZyl4hoHgrzPCn7/_buildManifest.js

@@ -0,0 +1 @@
+self.__BUILD_MANIFEST=function(s,c,e,t,a,r){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},"/":["static/chunks/pages/index-6b0d9e5031b70c58.js"],"/_error":["static/chunks/pages/_error-1be831200e60c5c0.js"],"/clusters":[s,e,c,t,r,"static/chunks/pages/clusters-9e6d1ec6e1ac5b29.js"],"/clusters/[cluster]":[s,e,c,t,a,r,"static/chunks/pages/clusters/[cluster]-9529d9e882a0e75c.js"],"/clusters/[cluster]/[job]":[s,c,"static/chunks/pages/clusters/[cluster]/[job]-37c042a356f8e608.js"],"/infra":[s,c,"static/chunks/pages/infra-e690d864aa00e2ea.js"],"/jobs":[s,e,c,t,a,"static/chunks/pages/jobs-73d5e0c369d00346.js"],"/jobs/[job]":[s,c,"static/chunks/pages/jobs/[job]-db6558a5ec687011.js"],"/users":[s,c,"static/chunks/pages/users-2d319455c3f1c3e2.js"],"/workspaces":["static/chunks/9f96d65d-5a3e4af68c26849e.js",s,e,"static/chunks/498-d7722313e5e5b4e6.js",c,t,a,"static/chunks/pages/workspaces-02a7b60f2ead275f.js"],sortedPages:["/","/_app","/_error","/clusters","/clusters/[cluster]","/clusters/[cluster]/[job]","/infra","/jobs","/jobs/[job]","/users","/workspaces"]}}("static/chunks/573-f17bd89d9f9118b3.js","static/chunks/480-ee58038f1a4afd5c.js","static/chunks/488-50d843fdb5396d32.js","static/chunks/734-5f5ce8f347b7f417.js","static/chunks/938-f347f6144075b0c8.js","static/chunks/578-7a4795009a56430c.js"),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();