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

sky/server/server.py

@@ -6,6 +6,7 @@ import base64
 import contextlib
 import dataclasses
 import datetime
+import hashlib
 import json
 import logging
 import multiprocessing
@@ -31,7 +32,9 @@ from sky import core
 from sky import exceptions
 from sky import execution
 from sky import global_user_state
+from sky import models
 from sky import sky_logging
+from sky import skypilot_config
 from sky.clouds import service_catalog
 from sky.data import storage_utils
 from sky.jobs.server import server as jobs_rest
@@ -110,6 +113,38 @@ class RequestIDMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
         return response
 
 
+def _get_auth_user_header(request: fastapi.Request) -> Optional[models.User]:
+    if 'X-Auth-Request-Email' not in request.headers:
+        return None
+    user_name = request.headers['X-Auth-Request-Email']
+    user_hash = hashlib.md5(
+        user_name.encode()).hexdigest()[:common_utils.USER_HASH_LENGTH]
+    return models.User(id=user_hash, name=user_name)
+
+
+class AuthProxyMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
+    """Middleware to handle auth proxy."""
+
+    async def dispatch(self, request: fastapi.Request, call_next):
+        auth_user = _get_auth_user_header(request)
+        body = await request.body()
+        if auth_user and body:
+            try:
+                original_json = await request.json()
+            except json.JSONDecodeError as e:
+                logger.error(f'Error parsing request JSON: {e}')
+            else:
+                logger.debug(f'Overriding user for {request.state.request_id}: '
+                             f'{auth_user.name}, {auth_user.id}')
+                if 'env_vars' in original_json:
+                    original_json['env_vars'][
+                        constants.USER_ID_ENV_VAR] = auth_user.id
+                    original_json['env_vars'][
+                        constants.USER_ENV_VAR] = auth_user.name
+                request._body = json.dumps(original_json).encode('utf-8')  # pylint: disable=protected-access
+        return await call_next(request)
+
+
 # Default expiration time for upload ids before cleanup.
 _DEFAULT_UPLOAD_EXPIRATION_TIME = datetime.timedelta(hours=1)
 # Key: (upload_id, user_hash), Value: the time when the upload id needs to be
@@ -216,6 +251,7 @@ app.add_middleware(
     allow_headers=['*'],
     # TODO(syang): remove X-Request-ID when v0.10.0 is released.
     expose_headers=['X-Request-ID', 'X-Skypilot-Request-ID'])
+app.add_middleware(AuthProxyMiddleware)
 app.add_middleware(RequestIDMiddleware)
 app.include_router(jobs_rest.router, prefix='/jobs', tags=['jobs'])
 app.include_router(serve_rest.router, prefix='/serve', tags=['serve'])
@@ -223,8 +259,18 @@ app.include_router(serve_rest.router, prefix='/serve', tags=['serve'])
 
 @app.get('/token')
 async def token(request: fastapi.Request) -> fastapi.responses.HTMLResponse:
+    # If we have auth info, save this user to the database.
+    user = _get_auth_user_header(request)
+    if user is not None:
+        global_user_state.add_or_update_user(user)
+
+    token_data = {
+        'v': 1,  # Token version number, bump for backwards incompatible.
+        'user': user.id if user is not None else None,
+        'cookies': request.cookies,
+    }
     # Use base64 encoding to avoid having to escape anything in the HTML.
-    json_bytes = json.dumps(request.cookies).encode('utf-8')
+    json_bytes = json.dumps(token_data).encode('utf-8')
     base64_str = base64.b64encode(json_bytes).decode('utf-8')
 
     html_dir = pathlib.Path(__file__).parent / 'html'
@@ -236,8 +282,10 @@ async def token(request: fastapi.Request) -> fastapi.responses.HTMLResponse:
         raise fastapi.HTTPException(
             status_code=500, detail='Token page template not found.') from e
 
+    user_info_string = f'Logged in as {user.name}' if user is not None else ''
     html_content = html_content.replace(
-        'SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER', base64_str)
+        'SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER',
+        base64_str).replace('USER_PLACEHOLDER', user_info_string)
 
     return fastapi.responses.HTMLResponse(
         content=html_content,
@@ -263,17 +311,30 @@ async def check(request: fastapi.Request,
 
 
 @app.get('/enabled_clouds')
-async def enabled_clouds(request: fastapi.Request) -> None:
+async def enabled_clouds(request: fastapi.Request,
+                         workspace: Optional[str] = None) -> None:
     """Gets enabled clouds on the server."""
     executor.schedule_request(
         request_id=request.state.request_id,
         request_name='enabled_clouds',
-        request_body=payloads.RequestBody(),
+        request_body=payloads.EnabledCloudsBody(workspace=workspace),
         func=core.enabled_clouds,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
 
 
+@app.get('/workspaces')
+async def get_workspace_config(request: fastapi.Request) -> None:
+    """Gets workspace config on the server."""
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='workspaces',
+        request_body=payloads.RequestBody(),
+        func=skypilot_config.get_workspaces,
+        schedule_type=requests_lib.ScheduleType.SHORT,
+    )
+
+
 @app.post('/realtime_kubernetes_gpu_availability')
 async def realtime_kubernetes_gpu_availability(
     request: fastapi.Request,
@@ -909,6 +970,33 @@ async def local_down(request: fastapi.Request) -> None:
     )
 
 
+@app.post('/ssh_up')
+async def ssh_up(request: fastapi.Request,
+                 ssh_up_body: payloads.SSHUpBody) -> None:
+    """Deploys a Kubernetes cluster on SSH targets."""
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='ssh_up',
+        request_body=ssh_up_body,
+        func=core.ssh_up,
+        schedule_type=requests_lib.ScheduleType.LONG,
+    )
+
+
+@app.post('/ssh_down')
+async def ssh_down(request: fastapi.Request,
+                   ssh_up_body: payloads.SSHUpBody) -> None:
+    """Tears down a Kubernetes cluster on SSH targets."""
+    # We still call ssh_up but with cleanup=True
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='ssh_down',
+        request_body=ssh_up_body,
+        func=core.ssh_up,  # Reuse ssh_up function with cleanup=True
+        schedule_type=requests_lib.ScheduleType.LONG,
+    )
+
+
 # === API server related APIs ===
 @app.get('/api/get')
 async def api_get(request_id: str) -> requests_lib.RequestPayload:
@@ -1086,7 +1174,7 @@ async def api_status(
 
 
 @app.get('/api/health')
-async def health() -> Dict[str, str]:
+async def health(request: fastapi.Request) -> Dict[str, Any]:
     """Checks the health of the API server.
 
     Returns:
@@ -1098,12 +1186,14 @@ async def health() -> Dict[str, str]:
           disk, which can be used to warn about restarting the API server
         - commit: str; The commit hash of SkyPilot used for API server.
     """
+    user = _get_auth_user_header(request)
     return {
         'status': common.ApiServerStatus.HEALTHY.value,
         'api_version': server_constants.API_VERSION,
         'version': sky.__version__,
         'version_on_disk': common.get_skypilot_version_on_disk(),
         'commit': sky.__commit__,
+        'user': user.to_dict() if user is not None else None,
     }
 
 
@@ -1185,6 +1275,19 @@ async def kubernetes_pod_ssh_proxy(
         proc.terminate()
 
 
+@app.get('/all_contexts')
+async def all_contexts(request: fastapi.Request) -> None:
+    """Gets all Kubernetes and SSH node pool contexts."""
+
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='all_contexts',
+        request_body=payloads.RequestBody(),
+        func=core.get_all_contexts,
+        schedule_type=requests_lib.ScheduleType.SHORT,
+    )
+
+
 # === Internal APIs ===
 @app.get('/api/completion/cluster_name')
 async def complete_cluster_name(incomplete: str,) -> List[str]:

sky/setup_files/dependencies.py

@@ -130,6 +130,7 @@ extras_require: Dict[str, List[str]] = {
     'oci': ['oci'] + local_ray,
     # Kubernetes 32.0.0 has an authentication bug: https://github.com/kubernetes-client/python/issues/2333 # pylint: disable=line-too-long
     'kubernetes': ['kubernetes>=20.0.0,!=32.0.0', 'websockets'],
+    'ssh': ['kubernetes>=20.0.0,!=32.0.0', 'websockets'],
     'remote': remote,
     # For the container registry auth api. Reference:
     # https://github.com/runpod/runpod-python/releases/tag/1.6.1

sky/skylet/constants.py

@@ -378,7 +378,8 @@ OVERRIDEABLE_CONFIG_KEYS_IN_TASK: List[Tuple[str, ...]] = [
 # we skip the following keys because they are meant to be client-side configs.
 SKIPPED_CLIENT_OVERRIDE_KEYS: List[Tuple[str, ...]] = [('admin_policy',),
                                                        ('api_server',),
-                                                       ('allowed_clouds',)]
+                                                       ('allowed_clouds',),
+                                                       ('workspaces',)]
 
 # Constants for Azure blob storage
 WAIT_FOR_STORAGE_ACCOUNT_CREATION = 60
@@ -405,3 +406,5 @@ SKY_USER_FILE_PATH = '~/.sky/generated'
 
 # Environment variable that is set to 'true' if this is a skypilot server.
 ENV_VAR_IS_SKYPILOT_SERVER = 'IS_SKYPILOT_SERVER'
+
+SKYPILOT_DEFAULT_WORKSPACE = 'default'

sky/skypilot_config.py

@@ -123,6 +123,8 @@ class ConfigContext:
 _global_config_context = ConfigContext()
 _reload_config_lock = threading.Lock()
 
+_active_workspace_context = threading.local()
+
 
 def _get_config_context() -> ConfigContext:
     """Get config context for current context.
@@ -194,8 +196,7 @@ def get_user_config() -> config_utils.Config:
 
     # load the user config file
     if os.path.exists(user_config_path):
-        user_config = parse_config_file(user_config_path)
-        _validate_config(user_config, user_config_path)
+        user_config = parse_and_validate_config_file(user_config_path)
     else:
         user_config = config_utils.Config()
     return user_config
@@ -223,8 +224,7 @@ def _get_project_config() -> config_utils.Config:
 
     # load the project config file
     if os.path.exists(project_config_path):
-        project_config = parse_config_file(project_config_path)
-        _validate_config(project_config, project_config_path)
+        project_config = parse_and_validate_config_file(project_config_path)
     else:
         project_config = config_utils.Config()
     return project_config
@@ -252,8 +252,7 @@ def get_server_config() -> config_utils.Config:
 
     # load the server config file
     if os.path.exists(server_config_path):
-        server_config = parse_config_file(server_config_path)
-        _validate_config(server_config, server_config_path)
+        server_config = parse_and_validate_config_file(server_config_path)
     else:
         server_config = config_utils.Config()
     return server_config
@@ -287,6 +286,60 @@ def get_nested(keys: Tuple[str, ...],
         disallowed_override_keys=None)
 
 
+def get_workspace_cloud(cloud: str,
+                        workspace: Optional[str] = None) -> config_utils.Config:
+    """Returns the workspace config."""
+    if workspace is None:
+        workspace = get_active_workspace()
+    clouds = get_nested(keys=(
+        'workspaces',
+        workspace,
+    ), default_value=None)
+    if clouds is None:
+        return config_utils.Config()
+    return clouds.get(cloud.lower(), config_utils.Config())
+
+
+@contextlib.contextmanager
+def local_active_workspace_ctx(workspace: str) -> Iterator[None]:
+    """Temporarily set the active workspace IN CURRENT THREAD.
+
+    Note: having this function thread-local is error-prone, as wrapping some
+    operations with this will not have the underlying threads to get the
+    correct active workspace. However, we cannot make it global either, as
+    backend_utils.refresh_cluster_status() will be called in multiple threads,
+    and they may have different active workspaces for different threads.
+
+    # TODO(zhwu): make this function global by default and able to be set
+    # it to thread-local with an argument.
+
+    Args:
+        workspace: The workspace to set as active.
+
+    Raises:
+        RuntimeError: If called from a non-main thread.
+    """
+    original_workspace = get_active_workspace()
+    if original_workspace == workspace:
+        # No change, do nothing.
+        yield
+        return
+    _active_workspace_context.workspace = workspace
+    logger.debug(f'Set context workspace: {workspace}')
+    yield
+    logger.debug(f'Reset context workspace: {original_workspace}')
+    _active_workspace_context.workspace = original_workspace
+
+
+def get_active_workspace(force_user_workspace: bool = False) -> str:
+    context_workspace = getattr(_active_workspace_context, 'workspace', None)
+    if not force_user_workspace and context_workspace is not None:
+        logger.debug(f'Get context workspace: {context_workspace}')
+        return context_workspace
+    return get_nested(keys=('active_workspace',),
+                      default_value=constants.SKYPILOT_DEFAULT_WORKSPACE)
+
+
 def set_nested(keys: Tuple[str, ...], value: Any) -> Dict[str, Any]:
     """Returns a deep-copied config with the nested key set to value.
 
@@ -357,7 +410,7 @@ def _reload_config() -> None:
         _reload_config_as_client()
 
 
-def parse_config_file(config_path: str) -> config_utils.Config:
+def parse_and_validate_config_file(config_path: str) -> config_utils.Config:
     config = config_utils.Config()
     try:
         config_dict = common_utils.read_yaml(config_path)
@@ -413,7 +466,7 @@ def _reload_config_from_internal_file(internal_config_path: str) -> None:
                 'exist. Please double check the path or unset the env var: '
                 f'unset {ENV_VAR_SKYPILOT_CONFIG}')
     logger.debug(f'Using config path: {config_path}')
-    _set_loaded_config(parse_config_file(config_path))
+    _set_loaded_config(parse_and_validate_config_file(config_path))
     _set_loaded_config_path(config_path)
 
 
@@ -512,6 +565,19 @@ def override_skypilot_config(
         override_configs=dict(override_configs),
         allowed_override_keys=None,
         disallowed_override_keys=constants.SKIPPED_CLIENT_OVERRIDE_KEYS)
+    workspace = config.get_nested(
+        keys=('active_workspace',),
+        default_value=constants.SKYPILOT_DEFAULT_WORKSPACE)
+    if (workspace != constants.SKYPILOT_DEFAULT_WORKSPACE and workspace
+            not in get_nested(keys=('workspaces',), default_value={})):
+        raise ValueError(f'Workspace {workspace} does not exist. '
+                         'Use `sky check` to see if it is defined on the API '
+                         'server and try again.')
+    # Initialize the active workspace context to the workspace specified, so
+    # that a new request is not affected by the previous request's workspace.
+    global _active_workspace_context
+    _active_workspace_context = threading.local()
+
     try:
         common_utils.validate_schema(
             config,
@@ -592,7 +658,7 @@ def _compose_cli_config(cli_config: Optional[List[str]]) -> config_utils.Config:
                     'Cannot use multiple --config flags with a config file.')
             config_source = maybe_config_path
             # cli_config is a path to a config file
-            parsed_config = parse_config_file(maybe_config_path)
+            parsed_config = parse_and_validate_config_file(maybe_config_path)
         else:  # cli_config is a comma-separated list of key-value pairs
             parsed_config = _parse_dotlist(cli_config)
         _validate_config(parsed_config, config_source)
@@ -623,3 +689,11 @@ def apply_cli_config(cli_config: Optional[List[str]]) -> Dict[str, Any]:
         overlay_skypilot_config(original_config=_get_loaded_config(),
                                 override_configs=parsed_config))
     return parsed_config
+
+
+def get_workspaces() -> Dict[str, Any]:
+    """Returns the workspace config."""
+    workspaces = get_nested(('workspaces',), default_value={})
+    if constants.SKYPILOT_DEFAULT_WORKSPACE not in workspaces:
+        workspaces[constants.SKYPILOT_DEFAULT_WORKSPACE] = {}
+    return workspaces

sky/templates/nebius-ray.yml.j2

@@ -46,6 +46,13 @@ available_node_types:
       InstanceType: {{instance_type}}
       ImageId: {{image_id}}
       DiskSize: {{disk_size}}
+      filesystems:
+        {%- for fs in filesystems %}
+        - filesystem_id: {{ fs.filesystem_id }}
+          filesystem_mount_tag: {{ fs.filesystem_mount_tag }}
+          filesystem_attach_mode: {{ fs.filesystem_attach_mode }}
+          filesystem_mount_path: {{ fs.filesystem_mount_path }}
+        {%- endfor %}
       UserData: |
         runcmd:
           - sudo sed -i 's/^#\?AllowTcpForwarding.*/AllowTcpForwarding yes/' /etc/ssh/sshd_config
@@ -130,6 +137,11 @@ setup_commands:
   - {%- for initial_setup_command in initial_setup_commands %}
     {{ initial_setup_command }}
     {%- endfor %}
+    {%- for fs in filesystems %}
+    sudo mkdir {{ fs.filesystem_mount_path }};
+    sudo mount -t virtiofs {{ fs.filesystem_mount_tag }} {{ fs.filesystem_mount_path }};
+    sudo chmod a+w {{ fs.filesystem_mount_path }};
+    {%- endfor %}
     sudo systemctl stop unattended-upgrades || true;
     sudo systemctl disable unattended-upgrades || true;
     sudo sed -i 's/Unattended-Upgrade "1"/Unattended-Upgrade "0"/g' /etc/apt/apt.conf.d/20auto-upgrades || true;

sky/utils/cli_utils/status_utils.py

@@ -48,7 +48,8 @@ class StatusColumn:
 def show_status_table(cluster_records: List[_ClusterRecord],
                       show_all: bool,
                       show_user: bool,
-                      query_clusters: Optional[List[str]] = None) -> int:
+                      query_clusters: Optional[List[str]] = None,
+                      show_workspaces: bool = False) -> int:
     """Compute cluster table values and display.
 
     Returns:
@@ -56,7 +57,6 @@ def show_status_table(cluster_records: List[_ClusterRecord],
         STOPPED.
     """
     # TODO(zhwu): Update the information for autostop clusters.
-
     status_columns = [
         StatusColumn('NAME', _get_name),
     ]
@@ -66,6 +66,9 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             StatusColumn('USER_ID', _get_user_hash, show_by_default=False))
 
     status_columns += [
+        StatusColumn('WORKSPACE',
+                     _get_workspace,
+                     show_by_default=show_workspaces),
         StatusColumn('INFRA', _get_infra, truncate=not show_all),
         StatusColumn('RESOURCES', _get_resources, truncate=not show_all),
         StatusColumn('STATUS', _get_status_colored),
@@ -106,12 +109,13 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             for cluster in query_clusters
             if cluster not in cluster_names
         ]
-        cluster_str = 'Cluster'
-        if len(not_found_clusters) > 1:
-            cluster_str += 's'
-        cluster_str += ' '
-        cluster_str += ', '.join(not_found_clusters)
-        click.echo(f'{cluster_str} not found.')
+        if not_found_clusters:
+            cluster_str = 'Cluster'
+            if len(not_found_clusters) > 1:
+                cluster_str += 's'
+            cluster_str += ' '
+            cluster_str += ', '.join(not_found_clusters)
+            click.echo(f'{cluster_str} not found.')
     elif not cluster_records:
         click.echo('No existing clusters.')
     return num_pending_autostop
@@ -243,6 +247,12 @@ def _get_status(cluster_record: _ClusterRecord,
     return cluster_record['status']
 
 
+def _get_workspace(cluster_record: _ClusterRecord,
+                   truncate: bool = True) -> str:
+    del truncate
+    return cluster_record['workspace']
+
+
 def _get_status_colored(cluster_record: _ClusterRecord,
                         truncate: bool = True) -> str:
     del truncate

sky/utils/infra_utils.py

@@ -86,6 +86,16 @@ class InfraInfo:
             cloud_name = 'kubernetes'  # Normalize k8s to kubernetes
             region = '/'.join(parts[1:]) if len(parts) >= 2 else None
             zone = None
+        elif cloud_name == 'ssh':
+            # For SSH, the entire string after "ssh/" is the
+            # node pool name. We prepend 'ssh-' for the internal implementation
+            # which reuses the context name.
+            # TODO(romilb): This is a workaround while we use the global
+            # kubeconfig to store the ssh contexts.
+            region = '/'.join(parts[1:]) if len(parts) >= 2 else None
+            if region:
+                region = f'ssh-{region}'
+            zone = None
         else:
             # For non-Kubernetes clouds, continue with regular parsing
             # but be careful to only split into max 3 parts
@@ -133,6 +143,12 @@ class InfraInfo:
         if zone is None:
             zone = '*'
 
+        # If the cloud is ssh, we remove the ssh- prefix from the region
+        # TODO(romilb): This is a workaround while we use the global
+        # kubeconfig to store the ssh contexts.
+        if region and region.startswith('ssh-'):
+            region = region[4:]
+
         # Build the parts list and filter out trailing wildcards
         parts = [cloud.lower(), region, zone]
         while parts and parts[-1] == '*':
@@ -160,7 +176,11 @@ class InfraInfo:
         if self.zone is not None and self.zone != '*':
             region_or_zone = self.zone
         elif self.region is not None and self.region != '*':
-            region_or_zone = self.region
+            # If using region, we remove the ssh- prefix if it exists for SSH
+            # Node Pools.
+            # TODO(romilb): This is a workaround while we use the global
+            # kubeconfig to store the ssh contexts.
+            region_or_zone = self.region.lstrip('ssh-')
 
         if region_or_zone is not None and truncate:
             region_or_zone = common_utils.truncate_long_string(

sky/utils/kubernetes/cleanup-tunnel.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# cleanup-tunnel.sh - Script to clean up SSH tunnels for a Kubernetes context
+
+# Usage: cleanup-tunnel.sh CONTEXT_NAME
+
+CONTEXT="${1:-default}"
+TUNNEL_DIR="$HOME/.sky/ssh_node_pools_info"
+PID_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.pid"
+LOG_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.log"
+LOCK_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.lock"
+
+# Get the port from kubeconfig if available
+KUBE_PORT=$(kubectl config view --minify --context="$CONTEXT" -o jsonpath='{.clusters[0].cluster.server}' 2>/dev/null | grep -o ":[0-9]\+" | tr -d ":" || echo "")
+
+if [[ -z "$KUBE_PORT" ]]; then
+    # Default to 6443 if we can't determine the port
+    KUBE_PORT=6443
+    echo "$(date): Could not determine port from kubeconfig, using default port $KUBE_PORT" >> "$LOG_FILE"
+else
+    echo "$(date): Found port $KUBE_PORT in kubeconfig for context $CONTEXT" >> "$LOG_FILE"
+fi
+
+# Check if PID file exists
+if [[ -f "$PID_FILE" ]]; then
+    OLD_PID=$(cat "$PID_FILE")
+    
+    # Log the cleanup attempt
+    echo "$(date): Attempting to clean up tunnel for context $CONTEXT (PID: $OLD_PID, Port: $KUBE_PORT)" >> "$LOG_FILE"
+    
+    # Try to kill the process
+    if kill -0 "$OLD_PID" 2>/dev/null; then
+        # Process exists, kill it
+        kill "$OLD_PID" 2>/dev/null
+        
+        # Wait a moment and check if it's really gone
+        sleep 1
+        if kill -0 "$OLD_PID" 2>/dev/null; then
+            # Still running, force kill
+            kill -9 "$OLD_PID" 2>/dev/null
+            echo "$(date): Forcefully terminated tunnel process $OLD_PID" >> "$LOG_FILE"
+        else
+            echo "$(date): Successfully terminated tunnel process $OLD_PID" >> "$LOG_FILE"
+        fi
+    else
+        echo "$(date): No running process found with PID $OLD_PID" >> "$LOG_FILE"
+    fi
+    
+    # Remove PID file
+    rm -f "$PID_FILE"
+else
+    echo "$(date): No PID file found for context $CONTEXT. Nothing to clean up." >> "$LOG_FILE"
+fi
+
+# Clean up lock file if it exists
+rm -f "$LOCK_FILE"
+
+# Check if port is still in use
+if nc -z localhost "$KUBE_PORT" 2>/dev/null; then
+    echo "$(date): Warning: Port $KUBE_PORT is still in use after cleanup. Another process might be using it." >> "$LOG_FILE"
+fi
+
+echo "$(date): Cleanup complete for context $CONTEXT" >> "$LOG_FILE" 

sky/utils/kubernetes/create_cluster.sh

@@ -85,6 +85,7 @@ fi
 if kind get clusters | grep -q skypilot; then
     echo "Local cluster already exists. Exiting."
     # Switch context to the local cluster
+    kind export kubeconfig --name skypilot
     kubectl config use-context kind-skypilot
     exit 100
 fi