skypilot-nightly 1.0.0.dev20250616__py3-none-any.whl → 1.0.0.dev20250618__py3-none-any.whl

sky/client/sdk.py

@@ -1856,6 +1856,7 @@ def api_start(
     deploy: bool = False,
     host: str = '127.0.0.1',
     foreground: bool = False,
+    enable_basic_auth: bool = False,
 ) -> None:
     """Starts the API server.
 
@@ -1869,6 +1870,8 @@ def api_start(
             if deploy is True, to allow remote access.
         foreground: Whether to run the API server in the foreground (run in
             the current process).
+        enable_basic_auth: Whether to enable basic authentication
+            in the API server.
     Returns:
         None
     """
@@ -1887,7 +1890,8 @@ def api_start(
                              'from the config file and/or unset the '
                              'SKYPILOT_API_SERVER_ENDPOINT environment '
                              'variable.')
-    server_common.check_server_healthy_or_start_fn(deploy, host, foreground)
+    server_common.check_server_healthy_or_start_fn(deploy, host, foreground,
+                                                   enable_basic_auth)
     if foreground:
         # Explain why current process exited
         logger.info('API server is already running:')
@@ -1990,7 +1994,8 @@ def api_login(endpoint: Optional[str] = None, get_token: bool = False) -> None:
         raise click.BadParameter('Endpoint must be a valid URL.')
     endpoint = endpoint.rstrip('/')
 
-    server_status = server_common.check_server_healthy(endpoint)
+    server_status, api_server_info = server_common.check_server_healthy(
+        endpoint)
     if server_status == server_common.ApiServerStatus.NEEDS_AUTH or get_token:
         # We detected an auth proxy, so go through the auth proxy cookie flow.
         token: Optional[str] = None
@@ -2121,6 +2126,21 @@ def api_login(endpoint: Optional[str] = None, get_token: bool = False) -> None:
                       'w',
                       encoding='utf-8') as f:
                 f.write(user_hash)
+    else:
+        # Check if basic auth is enabled
+        if api_server_info.basic_auth_enabled:
+            if api_server_info.user is None:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        'Basic auth is enabled but no valid user is found')
+            # Set the user hash in the local file
+            user_hash = api_server_info.user.get('id')
+            if not user_hash or not common_utils.is_valid_user_hash(user_hash):
+                raise ValueError(f'Invalid user hash: {user_hash}')
+            with open(os.path.expanduser('~/.sky/user_hash'),
+                      'w',
+                      encoding='utf-8') as f:
+                f.write(user_hash)
 
     # Set the endpoint in the config file
     config_path = pathlib.Path(

sky/clouds/kubernetes.py

@@ -602,6 +602,10 @@ class Kubernetes(clouds.Cloud):
             None,
             override_configs=resources.cluster_config_overrides)
 
+        k8s_kueue_local_queue_name = skypilot_config.get_nested(
+            ('kubernetes', 'kueue', 'local_queue_name'),
+            None,
+            override_configs=resources.cluster_config_overrides)
         deploy_vars = {
             'instance_type': resources.instance_type,
             'custom_resources': custom_resources,
@@ -619,6 +623,7 @@ class Kubernetes(clouds.Cloud):
             'k8s_service_account_name': k8s_service_account_name,
             'k8s_automount_sa_token': 'true',
             'k8s_fuse_device_required': fuse_device_required,
+            'k8s_kueue_local_queue_name': k8s_kueue_local_queue_name,
             # Namespace to run the fusermount-server daemonset in
             'k8s_skypilot_system_namespace': _SKYPILOT_SYSTEM_NAMESPACE,
             'k8s_fusermount_shared_dir': _FUSERMOUNT_SHARED_DIR,
@@ -646,6 +651,9 @@ class Kubernetes(clouds.Cloud):
                 (constants.PERSISTENT_SETUP_SCRIPT_PATH),
             'k8s_high_availability_deployment_run_script_dir':
                 (constants.PERSISTENT_RUN_SCRIPT_DIR),
+            'k8s_high_availability_restarting_signal_file':
+                (constants.PERSISTENT_RUN_RESTARTING_SIGNAL_FILE),
+            'sky_python_cmd': constants.SKY_PYTHON_CMD,
             'k8s_high_availability_storage_class_name':
                 (k8s_ha_storage_class_name),
             'avoid_label_keys': avoid_label_keys,

sky/clouds/scp.py

@@ -59,14 +59,15 @@ class SCP(clouds.Cloud):
         clouds.CloudImplementationFeatures.CUSTOM_NETWORK_TIER:
             ('Custom network tier is currently not supported in '
              f'{_REPR}.'),
-        clouds.CloudImplementationFeatures.OPEN_PORTS:
-            (f'Opening ports is currently not supported on {_REPR}.'),
         clouds.CloudImplementationFeatures.HIGH_AVAILABILITY_CONTROLLERS:
             (f'High availability controllers are not supported on {_REPR}.'),
     }
 
     _INDENT_PREFIX = '    '
 
+    PROVISIONER_VERSION = clouds.ProvisionerVersion.SKYPILOT
+    STATUS_VERSION = clouds.StatusVersion.SKYPILOT
+
     @classmethod
     def _unsupported_features_for_resources(
         cls, resources: 'resources_lib.Resources'
@@ -243,7 +244,7 @@ class SCP(clouds.Cloud):
                                                  clouds='scp')
         if acc is not None:
             assert len(acc) == 1, acc
-            image_id = catalog.get_image_id_from_tag('skypilot:gpu-ubuntu-1804',
+            image_id = catalog.get_image_id_from_tag('skypilot:gpu-ubuntu-2204',
                                                      region_name,
                                                      clouds='scp')
         if image_id is not None:
@@ -325,7 +326,7 @@ class SCP(clouds.Cloud):
         """Checks if the user has access credentials to
         SCP's compute service."""
         try:
-            scp_utils.SCPClient().list_instances()
+            scp_utils.SCPClient().get_instances()
         except (AssertionError, KeyError, scp_utils.SCPClientError,
                 scp_utils.SCPCreationFailError):
             return False, (
@@ -374,25 +375,5 @@ class SCP(clouds.Cloud):
                      region: Optional[str], zone: Optional[str],
                      **kwargs) -> List[status_lib.ClusterStatus]:
         del tag_filters, region, zone, kwargs  # Unused.
-
-        # TODO: Multi-node is not supported yet.
-
-        status_map = {
-            'CREATING': status_lib.ClusterStatus.INIT,
-            'EDITING': status_lib.ClusterStatus.INIT,
-            'RUNNING': status_lib.ClusterStatus.UP,
-            'STARTING': status_lib.ClusterStatus.INIT,
-            'RESTARTING': status_lib.ClusterStatus.INIT,
-            'STOPPING': status_lib.ClusterStatus.STOPPED,
-            'STOPPED': status_lib.ClusterStatus.STOPPED,
-            'TERMINATING': None,
-            'TERMINATED': None,
-        }
-        status_list = []
-        vms = scp_utils.SCPClient().list_instances()
-        for node in vms:
-            if node['virtualServerName'] == name:
-                node_status = status_map[node['virtualServerState']]
-                if node_status is not None:
-                    status_list.append(node_status)
-        return status_list
+        # TODO: deprecate this method
+        assert False, 'This code path should not be used.'

sky/clouds/utils/scp_utils.py

@@ -184,7 +184,7 @@ class SCPClient:
 
     def create_instance(self, instance_config):
         """Launch new instances."""
-        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers'
+        url = f'{API_ENDPOINT}/virtual-server/v4/virtual-servers'
         return self._post(url, instance_config)
 
     @_retry
@@ -226,105 +226,113 @@ class SCPClient:
         raise_scp_error(response)
         return response.json()
 
-    def create_security_group(self, zone_id, vpc, sg_name):
+    def create_security_group(self, zone_id, vpc_id, sg_name):
         url = f'{API_ENDPOINT}/security-group/v3/security-groups'
         request_body = {
             'loggable': False,
             'securityGroupName': sg_name,
             'serviceZoneId': zone_id,
-            'vpcId': vpc,
-            'securityGroupDescription': 'skypilot sg'
+            'vpcId': vpc_id,
+            'securityGroupDescription': 'sky security group'
         }
         return self._post(url, request_body)
 
-    def add_security_group_in_rule(self, sg_id):
-        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
-        request_body = {
-            'ruleDirection': 'IN',
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }],
-            'sourceIpAddresses': ['0.0.0.0/0'],
-            'ruleDescription': 'skypilot ssh rule'
-        }
-        return self._post(url, request_body)
-
-    def add_security_group_out_rule(self, sg_id):
-        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
-        request_body = {
-            'ruleDirection': 'OUT',
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '21'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '80'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '443'
-            }],
-            'destinationIpAddresses': ['0.0.0.0/0'],
-            'ruleDescription': 'skypilot out rule'
-        }
-        return self._post(url, request_body)
-
-    def add_firewall_inbound_rule(self, firewall_id, internal_ip):
-        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {
-            'sourceIpAddresses': ['0.0.0.0/0'],
-            'destinationIpAddresses': [internal_ip],
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }],
-            'ruleDirection': 'IN',
-            'ruleAction': 'ALLOW',
-            'isRuleEnabled': True,
-            'ruleLocationType': 'FIRST',
-            'ruleDescription': 'description'
-        }
-        return self._post(url, request_body)
-
-    def add_firewall_outbound_rule(self, firewall_id, internal_ip):
-        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {
-            'sourceIpAddresses': [internal_ip],
-            'destinationIpAddresses': ['0.0.0.0/0'],
-            'services': [{
-                'serviceType': 'TCP',
-                'serviceValue': '21'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '22'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '80'
-            }, {
-                'serviceType': 'TCP',
-                'serviceValue': '443'
-            }],
-            'ruleDirection': 'OUT',
-            'ruleAction': 'ALLOW',
-            'isRuleEnabled': True,
-            'ruleLocationType': 'FIRST',
-            'ruleDescription': 'description'
-        }
-        return self._post(url, request_body)
+    def _security_group_rule_not_exist(self, sg_id, direction, ports):
+        response = self.get_security_group_rules(sg_id)
+        rules = []
+        for rule in response:
+            rule_direction = rule['ruleDirection']
+            if rule_direction == direction:
+                rules.append(rule)
+        for rule in rules:
+            port_list = ','.join(rule['tcpServices'])
+            port = ','.join(ports)
+            if port == port_list:
+                return False
+        return True
+
+    def add_security_group_rule(self, sg_id, direction,
+                                ports: Optional[List[str]]):
+        if ports is None:
+            if direction == 'IN':
+                ports = ['22']
+            else:
+                ports = ['21', '22', '80', '443']
+        services = []
+        for port in ports:
+            services.append({'serviceType': 'TCP', 'serviceValue': port})
+        if self._security_group_rule_not_exist(sg_id, direction, ports):
+            url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'  # pylint: disable=line-too-long
+            if direction == 'IN':
+                target_address = 'sourceIpAddresses'
+            else:
+                target_address = 'destinationIpAddresses'
+            request_body = {
+                'ruleDirection': direction,
+                'services': services,
+                target_address: ['0.0.0.0/0'],
+                'ruleDescription': 'sky security group rule'
+            }
+            return self._post(url, request_body)
+
+    def _firewall_rule_not_exist(self, firewall_id, internal_ip, direction,
+                                 ports):
+        response = self.get_firewall_rules(firewall_id)
+        rules = []
+        for rule in response:
+            if direction == 'IN':
+                if internal_ip == rule['destinationIpAddresses'][0]:
+                    rules.append(rule)
+            else:
+                if internal_ip == rule['sourceIpAddresses'][0]:
+                    rules.append(rule)
+        for rule in rules:
+            port_list = ','.join(rule['tcpServices'])
+            port = ','.join(ports)
+            if port == port_list:
+                return False
+        return True
+
+    def add_firewall_rule(self, firewall_id, internal_ip, direction, ports):
+        if ports is None:
+            if direction == 'IN':
+                ports = ['22']
+            else:
+                ports = ['21', '22', '80', '443']
+        services = []
+        for port in ports:
+            services.append({'serviceType': 'TCP', 'serviceValue': port})
+        if self._firewall_rule_not_exist(firewall_id, internal_ip, direction,
+                                         ports):
+            url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
+            if direction == 'IN':
+                source_ip = '0.0.0.0/0'
+                destination_ip = internal_ip
+            else:
+                source_ip = internal_ip
+                destination_ip = '0.0.0.0/0'
+            request_body = {
+                'sourceIpAddresses': [source_ip],
+                'destinationIpAddresses': [destination_ip],
+                'services': services,
+                'ruleDirection': direction,
+                'ruleAction': 'ALLOW',
+                'isRuleEnabled': True,
+                'ruleLocationType': 'FIRST',
+                'ruleDescription': 'sky firewall rule'
+            }
+            return self._post(url, request_body)
 
-    def terminate_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}'
+    def terminate_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}'
         return self._delete(url)
 
-    def list_instances(self) -> List[dict]:
+    def get_instances(self) -> List[dict]:
         """List existing instances."""
         url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers'
         return self._get(url)
 
-    def list_catalog(self) -> Dict[str, Any]:
+    def get_catalog(self) -> Dict[str, Any]:
         """List offered instances and their availability."""
         response = requests.get(f'{API_ENDPOINT}/instance-types',
                                 headers=self.headers)
@@ -362,89 +370,134 @@ class SCPClient:
         self.headers['X-Cmp-Timestamp'] = self.timestamp
 
     def set_signature(self, method: str, url: str) -> None:
-
         self.signature = self.get_signature(url=url, method=method)
         self.headers['X-Cmp-Signature'] = self.signature
 
-    def list_nic_details(self, virtual_server_id) -> List[dict]:
-        """List existing instances."""
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{virtual_server_id}/nics'  # pylint: disable=line-too-long
+    def get_nic(self, instance_id) -> List[dict]:
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/nics'  # pylint: disable=line-too-long
         return self._get(url)
 
-    def get_external_ip(self, virtual_server_id, ip):
-        nic_details_list = self.list_nic_details(
-            virtual_server_id=virtual_server_id)
-        for nic_details in nic_details_list:
-            if (nic_details['ip'] == ip and
-                    nic_details['subnetType'] == 'PUBLIC'):
-                return nic_details['natIp']
+    def get_external_ip(self, instance_id, ip):
+        nics = self.get_nic(instance_id=instance_id)
+        for nic in nics:
+            if (nic['ip'] == ip and nic['subnetType'] == 'PUBLIC'):
+                return nic['natIp']
         return None
 
-    def list_zones(self) -> List[dict]:
+    def get_zones(self) -> List[dict]:
         url = f'{API_ENDPOINT}/project/v3/projects/{self.project_id}/zones'
         return self._get(url)
 
-    def list_products(self, service_zone_id) -> List[dict]:
-        url = f'{API_ENDPOINT}/product/v2/zones/{service_zone_id}/products'
-        return self._get(url)
-
-    def list_product_groups(self, service_zone_id) -> List[dict]:
-        url = f'{API_ENDPOINT}/product/v2/zones/{service_zone_id}/product-groups'  # pylint: disable=line-too-long
-        return self._get(url)
-
-    def list_vpcs(self, service_zone_id) -> List[dict]:
+    def get_vpcs(self, service_zone_id) -> List[dict]:
         url = f'{API_ENDPOINT}/vpc/v2/vpcs?serviceZoneId={service_zone_id}'
         return self._get(url)
 
-    def list_subnets(self) -> List[dict]:
+    def get_subnets(self) -> List[dict]:
         url = f'{API_ENDPOINT}/subnet/v2/subnets?subnetTypes=PUBLIC'
         return self._get(url)
 
-    def del_security_group(self, sg_id):
+    def delete_security_group(self, sg_id):
         url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}'
         return self._delete(url)
 
-    def del_firwall_rules(self, firewall_id, rule_id_list):
+    def delete_firewall_rule(self, firewall_id, rule_ids):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
-        request_body = {'ruleDeletionType': 'PARTIAL', 'ruleIds': rule_id_list}
+        request_body = {'ruleDeletionType': 'PARTIAL', 'ruleIds': rule_ids}
         return self._delete(url, request_body=request_body)
 
-    def list_security_groups(self, vpc_id=None, sg_name=None):
+    def get_security_groups(self, vpc_id=None, sg_name=None):
         url = f'{API_ENDPOINT}/security-group/v2/security-groups'
         parameter = []
         if vpc_id is not None:
             parameter.append('vpcId=' + vpc_id)
         if sg_name is not None:
             parameter.append('securityGroupName=' + sg_name)
-        if parameter:
+        if len(parameter) > 0:
             url = url + '?' + '&'.join(parameter)
         return self._get(url)
 
-    def list_igw(self):
+    def get_internet_gateway(self):
         url = f'{API_ENDPOINT}/internet-gateway/v2/internet-gateways'
         return self._get(url)
 
-    def get_vm_info(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers/{vm_id}'
-        return self._get(url, contents_key=None)
-
-    def get_firewal_rule_info(self, firewall_id, rule_id):
+    def get_firewall_rule_info(self, firewall_id, rule_id):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules/{rule_id}'  # pylint: disable=line-too-long
         return self._get(url, contents_key=None)
 
-    def list_firwalls(self):
+    def get_firewalls(self):
         url = f'{API_ENDPOINT}/firewall/v2/firewalls'
         return self._get(url)
 
-    def list_service_zone_names(self):
+    def get_service_zone_names(self):
         url = f'{API_ENDPOINT}/project/v3/projects/{self.project_id}/zones'
         zone_contents = self._get(url)
         return [content['serviceZoneName'] for content in zone_contents]
 
-    def start_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}/start'
+    def start_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/start'  # pylint: disable=line-too-long
         return self._post(url=url, request_body={})
 
-    def stop_instance(self, vm_id):
-        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{vm_id}/stop'
+    def stop_instance(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/stop'  # pylint: disable=line-too-long
         return self._post(url=url, request_body={})
+
+    def get_security_group_rules(self, sg_id):
+        url = f'{API_ENDPOINT}/security-group/v2/security-groups/{sg_id}/rules'
+        return self._get(url)
+
+    def get_firewall_rules(self, firewall_id):
+        url = f'{API_ENDPOINT}/firewall/v2/firewalls/{firewall_id}/rules'
+        return self._get(url)
+
+    def get_instance_info(self, instance_id):
+        url = f'{API_ENDPOINT}/virtual-server/v3/virtual-servers/{instance_id}'
+        return self._get(url=url, contents_key=None)
+
+    def create_vpc(self, zone_id):
+        vpc_name = 'skyvpc' + zone_id[5:10]
+        request_body = {
+            'serviceZoneId': zone_id,
+            'vpcName': vpc_name,
+            'vpcDescription': 'sky vpc'
+        }
+        url = f'{API_ENDPOINT}/vpc/v3/vpcs'
+        return self._post(url, request_body)
+
+    def create_subnet(self, vpc_id, zone_id):
+        subnet_name = 'skysubnet' + zone_id[5:10]
+        request_body = {
+            'subnetCidrBlock': '192.168.0.0/24',
+            'subnetName': subnet_name,
+            'subnetType': 'PUBLIC',
+            'vpcId': vpc_id,
+            'subnetDescription': 'sky subnet'
+        }
+        url = f'{API_ENDPOINT}/subnet/v2/subnets'
+        return self._post(url, request_body)
+
+    def create_internet_gateway(self, vpc_id):
+        request_body = {
+            'firewallEnabled': True,
+            'firewallLoggable': False,
+            'internetGatewayType': 'SHARED',
+            'vpcId': vpc_id,
+            'internetGatewayDescription': 'sky internet gateway'
+        }
+        url = f'{API_ENDPOINT}/internet-gateway/v4/internet-gateways'
+        return self._post(url, request_body)
+
+    def get_vpc_info(self, vpc_id):
+        url = f'{API_ENDPOINT}/vpc/v2/vpcs/{vpc_id}'
+        return self._get(url=url, contents_key=None)
+
+    def get_subnet_info(self, subnet_id):
+        url = f'{API_ENDPOINT}/subnet/v2/subnets/{subnet_id}'
+        return self._get(url=url, contents_key=None)
+
+    def get_internet_gateway_info(self, internet_gateway_id):
+        url = f'{API_ENDPOINT}/internet-gateway/v2/internet-gateways/{internet_gateway_id}'  # pylint: disable=line-too-long
+        return self._get(url=url, contents_key=None)
+
+    def get_key_pairs(self):
+        url = f'{API_ENDPOINT}/key-pair/v1/key-pairs'
+        return self._get(url=url, contents_key=None)

sky/dashboard/out/404.html

@@ -1 +1 @@
-<!DOCTYPE html><html><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link rel="preload" href="/dashboard/_next/static/css/8e97adcaacc15293.css" as="style"/><link rel="stylesheet" href="/dashboard/_next/static/css/8e97adcaacc15293.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-1b69b196a4dbffef.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-32b2caae3445bf3b.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_error-1be831200e60c5c0.js" defer=""></script><script src="/dashboard/_next/static/OZxMW3bxAJmqgn5f4MdhO/_buildManifest.js" defer=""></script><script src="/dashboard/_next/static/OZxMW3bxAJmqgn5f4MdhO/_ssgManifest.js" defer=""></script></head><body><div id="__next"></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"statusCode":404}},"page":"/_error","query":{},"buildId":"OZxMW3bxAJmqgn5f4MdhO","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"/><meta name="next-head-count" content="2"/><link rel="preload" href="/dashboard/_next/static/css/6c12ecc3bd2239b6.css" as="style"/><link rel="stylesheet" href="/dashboard/_next/static/css/6c12ecc3bd2239b6.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-ebc2404fd6ce581c.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-c416e87d5c2715cf.js" defer=""></script><script src="/dashboard/_next/static/chunks/pages/_error-1be831200e60c5c0.js" defer=""></script><script src="/dashboard/_next/static/LRpGymRCqq-feuFyoWz4m/_buildManifest.js" defer=""></script><script src="/dashboard/_next/static/LRpGymRCqq-feuFyoWz4m/_ssgManifest.js" defer=""></script></head><body><div id="__next"></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"statusCode":404}},"page":"/_error","query":{},"buildId":"LRpGymRCqq-feuFyoWz4m","assetPrefix":"/dashboard","nextExport":true,"isFallback":false,"gip":true,"scriptLoader":[]}</script></body></html>

sky/dashboard/out/_next/static/{OZxMW3bxAJmqgn5f4MdhO → LRpGymRCqq-feuFyoWz4m}/_buildManifest.js

@@ -1 +1 @@
-self.__BUILD_MANIFEST=function(s,c,e,a,t,n,r,u,b,i,j,k,f){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},"/":["static/chunks/pages/index-6b0d9e5031b70c58.js"],"/_error":["static/chunks/pages/_error-1be831200e60c5c0.js"],"/clusters":["static/chunks/pages/clusters-82a651dbad53ec6e.js"],"/clusters/[cluster]":[s,c,e,a,t,r,b,n,i,u,j,k,f,"static/chunks/37-824c707421f6f003.js","static/chunks/pages/clusters/[cluster]-59950b2f83b66e48.js"],"/clusters/[cluster]/[job]":[s,c,e,a,t,n,"static/chunks/pages/clusters/[cluster]/[job]-89216c616dbaa9c5.js"],"/config":["static/chunks/pages/config-497a35a7ed49734a.js"],"/infra":["static/chunks/pages/infra-780860bcc1103945.js"],"/infra/[context]":["static/chunks/pages/infra/[context]-d2910be98e9227cb.js"],"/jobs":["static/chunks/pages/jobs-336ab80e270ce2ce.js"],"/jobs/[job]":[s,c,e,a,t,r,n,u,"static/chunks/pages/jobs/[job]-b3dbf38b51cb29be.js"],"/users":["static/chunks/pages/users-c69ffcab9d6e5269.js"],"/workspace/new":["static/chunks/pages/workspace/new-31aa8bdcb7592635.js"],"/workspaces":["static/chunks/pages/workspaces-82e6601baa5dd280.js"],"/workspaces/[name]":[s,c,e,a,t,r,b,n,i,u,j,k,f,"static/chunks/843-ab9c4f609239155f.js","static/chunks/pages/workspaces/[name]-c8c2191328532b7d.js"],sortedPages:["/","/_app","/_error","/clusters","/clusters/[cluster]","/clusters/[cluster]/[job]","/config","/infra","/infra/[context]","/jobs","/jobs/[job]","/users","/workspace/new","/workspaces","/workspaces/[name]"]}}("static/chunks/616-d6128fa9e7cae6e6.js","static/chunks/760-a89d354797ce7af5.js","static/chunks/799-3625946b2ec2eb30.js","static/chunks/804-4c9fc53aa74bc191.js","static/chunks/664-047bc03493fda379.js","static/chunks/470-4d1a5dbe58a8a2b9.js","static/chunks/798-c0525dc3f21e488d.js","static/chunks/969-20d54a9d998dc102.js","static/chunks/947-6620842ef80ae879.js","static/chunks/901-b424d293275e1fd7.js","static/chunks/856-c2c39c0912285e54.js","static/chunks/973-c807fc34f09c7df3.js","static/chunks/938-385d190b95815e11.js"),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();
+self.__BUILD_MANIFEST=function(s,c,e,a,t,n,r,u,i,b,j,k,f){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},"/":["static/chunks/pages/index-6b0d9e5031b70c58.js"],"/_error":["static/chunks/pages/_error-1be831200e60c5c0.js"],"/clusters":["static/chunks/pages/clusters-82a651dbad53ec6e.js"],"/clusters/[cluster]":[s,c,e,a,t,r,i,n,b,u,j,k,f,"static/chunks/37-3a4d77ad62932eaf.js","static/chunks/pages/clusters/[cluster]-36bc0962129f72df.js"],"/clusters/[cluster]/[job]":[s,c,e,a,t,n,"static/chunks/pages/clusters/[cluster]/[job]-89216c616dbaa9c5.js"],"/config":["static/chunks/pages/config-497a35a7ed49734a.js"],"/infra":["static/chunks/pages/infra-780860bcc1103945.js"],"/infra/[context]":["static/chunks/pages/infra/[context]-d2910be98e9227cb.js"],"/jobs":["static/chunks/pages/jobs-336ab80e270ce2ce.js"],"/jobs/[job]":[s,c,e,a,t,r,n,u,"static/chunks/pages/jobs/[job]-cf490d1fa38f3740.js"],"/users":["static/chunks/pages/users-928edf039219e47b.js"],"/workspace/new":["static/chunks/pages/workspace/new-31aa8bdcb7592635.js"],"/workspaces":["static/chunks/pages/workspaces-82e6601baa5dd280.js"],"/workspaces/[name]":[s,c,e,a,t,r,i,n,b,u,j,k,f,"static/chunks/843-b3040e493f6e7947.js","static/chunks/pages/workspaces/[name]-c4ff1ec05e2f3daf.js"],sortedPages:["/","/_app","/_error","/clusters","/clusters/[cluster]","/clusters/[cluster]/[job]","/config","/infra","/infra/[context]","/jobs","/jobs/[job]","/users","/workspace/new","/workspaces","/workspaces/[name]"]}}("static/chunks/616-d6128fa9e7cae6e6.js","static/chunks/760-a89d354797ce7af5.js","static/chunks/799-3625946b2ec2eb30.js","static/chunks/804-4c9fc53aa74bc191.js","static/chunks/664-047bc03493fda379.js","static/chunks/470-4d1a5dbe58a8a2b9.js","static/chunks/798-c0525dc3f21e488d.js","static/chunks/969-20d54a9d998dc102.js","static/chunks/947-6620842ef80ae879.js","static/chunks/901-b424d293275e1fd7.js","static/chunks/856-c2c39c0912285e54.js","static/chunks/973-db3c97c2bfbceb65.js","static/chunks/938-1493ac755eadeb35.js"),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();