dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

dstack/_internal/server/services/{pools.py → instances.py}

@@ -1,4 +1,3 @@
-import ipaddress
 import uuid
 from collections.abc import Container, Iterable
 from datetime import datetime, timezone
@@ -14,14 +13,10 @@ from dstack._internal.core.backends.base.offers import (
     offer_to_catalog_item,
     requirements_to_query_filter,
 )
-from dstack._internal.core.errors import (
-    ResourceExistsError,
-    ResourceNotExistsError,
-    ServerClientError,
-)
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.envs import Env
 from dstack._internal.core.models.instances import (
+    Instance,
     InstanceAvailability,
     InstanceConfiguration,
     InstanceOffer,
@@ -33,10 +28,8 @@ from dstack._internal.core.models.instances import (
     SSHConnectionParams,
     SSHKey,
 )
-from dstack._internal.core.models.pools import Instance, Pool, PoolInstances
 from dstack._internal.core.models.profiles import (
-    DEFAULT_POOL_NAME,
-    DEFAULT_POOL_TERMINATION_IDLE_TIME,
+    DEFAULT_FLEET_TERMINATION_IDLE_TIME,
     Profile,
     TerminationPolicy,
 )
@@ -47,198 +40,17 @@ from dstack._internal.core.services.profiles import get_termination
 from dstack._internal.server.models import (
     FleetModel,
     InstanceModel,
-    PoolModel,
     ProjectModel,
     UserModel,
 )
-from dstack._internal.server.services.locking import get_locker
 from dstack._internal.server.services.offers import generate_shared_offer
 from dstack._internal.server.services.projects import list_project_models, list_user_project_models
 from dstack._internal.utils import common as common_utils
-from dstack._internal.utils import random_names
-from dstack._internal.utils.common import get_current_datetime
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
 
 
-async def list_project_pools(session: AsyncSession, project: ProjectModel) -> List[Pool]:
-    pools = await list_project_pool_models(session=session, project=project)
-    if len(pools) == 0:
-        pool = await get_or_create_pool_by_name(session, project, DEFAULT_POOL_NAME)
-        pools.append(pool)
-    return [pool_model_to_pool(p) for p in pools]
-
-
-async def get_pool(
-    session: AsyncSession,
-    project: ProjectModel,
-    pool_name: str,
-    select_deleted: bool = False,
-    load_instance_fleets: bool = False,
-) -> Optional[PoolModel]:
-    filters = [
-        PoolModel.name == pool_name,
-        PoolModel.project_id == project.id,
-    ]
-    if not select_deleted:
-        filters.append(PoolModel.deleted == False)
-    query = select(PoolModel).where(*filters)
-    if load_instance_fleets:
-        query = query.options(joinedload(PoolModel.instances, InstanceModel.fleet))
-    res = await session.scalars(query)
-    return res.one_or_none()
-
-
-async def get_or_create_pool_by_name(
-    session: AsyncSession,
-    project: ProjectModel,
-    pool_name: Optional[str],
-    load_instance_fleets: bool = False,
-) -> PoolModel:
-    if pool_name is None:
-        if project.default_pool_id is not None:
-            return await get_default_pool_or_error(session, project, load_instance_fleets)
-        default_pool = await get_pool(
-            session, project, DEFAULT_POOL_NAME, load_instance_fleets=load_instance_fleets
-        )
-        if default_pool is not None:
-            await set_default_pool(session, project, DEFAULT_POOL_NAME)
-            return default_pool
-        return await create_pool(session, project, DEFAULT_POOL_NAME)
-    pool = await get_pool(session, project, pool_name, load_instance_fleets=load_instance_fleets)
-    if pool is not None:
-        return pool
-    return await create_pool(session, project, pool_name)
-
-
-async def get_default_pool_or_error(
-    session: AsyncSession, project: ProjectModel, load_instance_fleets: bool = False
-) -> PoolModel:
-    query = select(PoolModel).where(PoolModel.id == project.default_pool_id)
-    if load_instance_fleets:
-        query = query.options(joinedload(PoolModel.instances, InstanceModel.fleet))
-    res = await session.execute(query)
-    return res.scalar_one()
-
-
-async def create_pool(session: AsyncSession, project: ProjectModel, name: str) -> PoolModel:
-    pool = await get_pool(session, project, name)
-    if pool is not None:
-        raise ResourceExistsError()
-    pool = PoolModel(
-        name=name,
-        project_id=project.id,
-    )
-    session.add(pool)
-    await session.commit()
-    await session.refresh(pool)
-    if project.default_pool_id is None:
-        await set_default_pool(session, project, pool.name)
-    return pool
-
-
-async def list_project_pool_models(
-    session: AsyncSession, project: ProjectModel, select_deleted: bool = False
-) -> List[PoolModel]:
-    filters = [PoolModel.project_id == project.id]
-    if not select_deleted:
-        filters.append(PoolModel.deleted == select_deleted)
-    pools = await session.execute(
-        select(PoolModel).where(*filters).options(joinedload(PoolModel.instances))
-    )
-    return list(pools.scalars().unique().all())
-
-
-async def set_default_pool(session: AsyncSession, project: ProjectModel, pool_name: str):
-    pool = await get_pool(session, project, pool_name)
-    if pool is None:
-        raise ResourceNotExistsError("Pool not found")
-    project.default_pool = pool
-    await session.commit()
-
-
-async def delete_pool(session: AsyncSession, project: ProjectModel, pool_name: str) -> None:
-    # TODO force delete
-    pool = await get_pool(session, project, pool_name)
-    if pool is None:
-        raise ResourceNotExistsError("Pool not found")
-
-    pool_instances = get_pool_instances(pool)
-    for instance in pool_instances:
-        if instance.status != InstanceStatus.TERMINATED:
-            raise ServerClientError("Cannot delete pool with running instances")
-
-    pool.deleted = True
-    pool.deleted_at = get_current_datetime()
-    if project.default_pool_id == pool.id:
-        project.default_pool_id = None
-    await session.commit()
-
-
-def pool_model_to_pool(pool_model: PoolModel) -> Pool:
-    total = 0
-    available = 0
-    for instance in pool_model.instances:
-        if not instance.deleted:
-            total += 1
-            if instance.status.is_available():
-                available += 1
-    return Pool(
-        name=pool_model.name,
-        default=pool_model.project.default_pool_id == pool_model.id,
-        created_at=pool_model.created_at.replace(tzinfo=timezone.utc),
-        total_instances=total,
-        available_instances=available,
-    )
-
-
-async def remove_instance(
-    session: AsyncSession,
-    project: ProjectModel,
-    pool_name: str,
-    instance_name: str,
-    force: bool,
-):
-    # This is a buggy function since it doesn't lock instances (and never did correctly).
-    # No need to fix it since it's deprecated.
-    pool = await get_pool(session, project, pool_name)
-    if pool is None:
-        raise ResourceNotExistsError("Pool not found")
-    terminated = False
-    for instance in pool.instances:
-        if instance.name == instance_name:
-            if force or not instance.jobs:
-                instance.status = InstanceStatus.TERMINATING
-                terminated = True
-    await session.commit()
-    if not terminated:
-        raise ResourceNotExistsError("Could not find instance to terminate")
-
-
-async def show_pool_instances(
-    session: AsyncSession, project: ProjectModel, pool_name: Optional[str]
-) -> PoolInstances:
-    if pool_name is not None:
-        pool = await get_pool(session, project, pool_name, load_instance_fleets=True)
-        if pool is None:
-            raise ResourceNotExistsError("Pool not found")
-    else:
-        pool = await get_or_create_pool_by_name(
-            session, project, pool_name, load_instance_fleets=True
-        )
-    pool_instances = get_pool_instances(pool)
-    instances = list(map(instance_model_to_instance, pool_instances))
-    return PoolInstances(
-        name=pool.name,
-        instances=instances,
-    )
-
-
-def get_pool_instances(pool: PoolModel) -> List[InstanceModel]:
-    return [instance for instance in pool.instances if not instance.deleted]
-
-
 def instance_model_to_instance(instance_model: InstanceModel) -> Instance:
     instance = Instance(
         id=instance_model.id,
@@ -315,120 +127,6 @@ def get_instance_ssh_private_keys(instance_model: InstanceModel) -> tuple[str, O
     return host_private_key, proxy_private_keys[0]
 
 
-async def generate_instance_name(
-    session: AsyncSession,
-    project: ProjectModel,
-    pool_name: str,
-) -> str:
-    # FIXME: The locking is not correct since concurrently commited changes
-    # are not visible due to SQLite repeatable reads
-    lock, _ = get_locker().get_lockset(f"instance_names_{project.name}")
-    async with lock:
-        pool_instances = []
-        pool = await get_pool(session, project, pool_name)
-        if pool is not None:
-            pool_instances = get_pool_instances(pool)
-        names = {g.name for g in pool_instances}
-        while True:
-            name = f"{random_names.generate_name()}"
-            if name not in names:
-                return name
-
-
-async def add_remote(
-    session: AsyncSession,
-    project: ProjectModel,
-    pool_name: Optional[str],
-    instance_name: Optional[str],
-    instance_network: Optional[str],
-    region: Optional[str],
-    host: str,
-    port: int,
-    ssh_user: str,
-    ssh_keys: List[SSHKey],
-) -> Instance:
-    if instance_network is not None:
-        try:
-            interface = ipaddress.IPv4Interface(instance_network)
-            instance_network = str(interface.network)
-        except ipaddress.AddressValueError:
-            raise ServerClientError("Failed to parse network value")
-
-    # Check instance in all instances
-    pools = await list_project_pool_models(session, project)
-    for pool in pools:
-        for instance in pool.instances:
-            if instance.deleted:
-                continue
-            if instance.remote_connection_info is not None:
-                rci = RemoteConnectionInfo.__response__.parse_raw(instance.remote_connection_info)
-                if rci.host == host and rci.port == port and rci.ssh_user == ssh_user:
-                    return instance_model_to_instance(instance)
-
-    pool_model = await get_or_create_pool_by_name(session, project, pool_name)
-    pool_model_name = pool_model.name
-    if instance_name is None:
-        instance_name = await generate_instance_name(session, project, pool_model_name)
-
-    # TODO: doc - will overwrite after remote connected
-    instance_resource = Resources(cpus=2, memory_mib=8, gpus=[], spot=False)
-    instance_type = InstanceType(name="ssh", resources=instance_resource)
-
-    host_region = region if region is not None else "remote"
-
-    remote = JobProvisioningData(
-        backend=BackendType.REMOTE,
-        instance_type=instance_type,
-        instance_id=instance_name,
-        hostname=host,
-        region=host_region,
-        internal_ip=None,
-        instance_network=instance_network,
-        price=0,
-        username=ssh_user,
-        ssh_port=port,
-        dockerized=True,
-        backend_data="",
-        ssh_proxy=None,
-    )
-    offer = InstanceOfferWithAvailability(
-        backend=BackendType.REMOTE,
-        instance=instance_type,
-        region=host_region,
-        price=0.0,
-        availability=InstanceAvailability.AVAILABLE,
-    )
-
-    ssh_connection_info = RemoteConnectionInfo(
-        host=host, port=port, ssh_user=ssh_user, ssh_keys=ssh_keys
-    ).json()
-
-    im = InstanceModel(
-        id=uuid.uuid4(),
-        name=instance_name,
-        instance_num=0,
-        project=project,
-        pool=pool_model,
-        backend=BackendType.REMOTE,
-        created_at=common_utils.get_current_datetime(),
-        started_at=common_utils.get_current_datetime(),
-        status=InstanceStatus.PENDING,
-        unreachable=False,
-        job_provisioning_data=remote.json(),
-        remote_connection_info=ssh_connection_info,
-        offer=offer.json(),
-        region=offer.region,
-        price=offer.price,
-        termination_policy=TerminationPolicy.DONT_DESTROY,
-        termination_idle_time=0,
-    )
-    session.add(im)
-    await session.commit()
-
-    instance = instance_model_to_instance(im)
-    return instance
-
-
 def filter_pool_instances(
     pool_instances: List[InstanceModel],
     profile: Profile,
@@ -483,8 +181,6 @@ def filter_pool_instances(
             continue
         if instance.unreachable:
             continue
-        if profile.instance_name is not None and instance.name != profile.instance_name:
-            continue
         if status is not None and instance.status != status:
             continue
         jpd = get_instance_provisioning_data(instance)
@@ -567,11 +263,24 @@ def get_shared_pool_instances_with_offers(
     return instances_with_offers
 
 
-async def list_pools_instance_models(
+async def get_pool_instances(
+    session: AsyncSession,
+    project: ProjectModel,
+) -> List[InstanceModel]:
+    res = await session.execute(
+        select(InstanceModel).where(
+            InstanceModel.project_id == project.id,
+            InstanceModel.deleted == False,
+        )
+    )
+    instance_models = list(res.unique().scalars().all())
+    return instance_models
+
+
+async def list_projects_instance_models(
     session: AsyncSession,
     projects: List[ProjectModel],
     fleet_ids: Optional[Iterable[uuid.UUID]],
-    pool: Optional[PoolModel],
     only_active: bool,
     prev_created_at: Optional[datetime],
     prev_id: Optional[uuid.UUID],
@@ -583,8 +292,6 @@ async def list_pools_instance_models(
     ]
     if fleet_ids is not None:
         filters.append(InstanceModel.fleet_id.in_(fleet_ids))
-    if pool is not None:
-        filters.append(InstanceModel.pool_id == pool.id)
     if only_active:
         filters.extend(
             [
@@ -628,18 +335,17 @@ async def list_pools_instance_models(
         .where(*filters)
         .order_by(*order_by)
         .limit(limit)
-        .options(joinedload(InstanceModel.pool), joinedload(InstanceModel.fleet))
+        .options(joinedload(InstanceModel.fleet))
     )
     instance_models = list(res.unique().scalars().all())
     return instance_models
 
 
-async def list_user_pool_instances(
+async def list_user_instances(
     session: AsyncSession,
     user: UserModel,
     project_names: Optional[Container[str]],
     fleet_ids: Optional[Iterable[uuid.UUID]],
-    pool_name: Optional[str],
     only_active: bool,
     prev_created_at: Optional[datetime],
     prev_id: Optional[uuid.UUID],
@@ -653,24 +359,15 @@ async def list_user_pool_instances(
     if not projects:
         return []
 
-    pool = None
     if project_names is not None:
         projects = [proj for proj in projects if proj.name in project_names]
         if len(projects) == 0:
             return []
-        if pool_name is not None:
-            pool = await get_pool(
-                session=session,
-                project=projects[0],
-                pool_name=pool_name,
-                select_deleted=(not only_active),
-            )
-
-    instance_models = await list_pools_instance_models(
+
+    instance_models = await list_projects_instance_models(
         session=session,
         projects=projects,
         fleet_ids=fleet_ids,
-        pool=pool,
         only_active=only_active,
         prev_created_at=prev_created_at,
         prev_id=prev_id,
@@ -699,7 +396,6 @@ async def create_instance_model(
     session: AsyncSession,
     project: ProjectModel,
     user: UserModel,
-    pool: PoolModel,
     profile: Profile,
     requirements: Requirements,
     instance_name: str,
@@ -709,7 +405,7 @@ async def create_instance_model(
     blocks: Union[Literal["auto"], int],
 ) -> InstanceModel:
     termination_policy, termination_idle_time = get_termination(
-        profile, DEFAULT_POOL_TERMINATION_IDLE_TIME
+        profile, DEFAULT_FLEET_TERMINATION_IDLE_TIME
     )
     instance_id = uuid.uuid4()
     project_ssh_key = SSHKey(
@@ -730,7 +426,6 @@ async def create_instance_model(
         name=instance_name,
         instance_num=instance_num,
         project=project,
-        pool=pool,
         created_at=common_utils.get_current_datetime(),
         status=InstanceStatus.PENDING,
         unreachable=False,
@@ -748,7 +443,6 @@ async def create_instance_model(
 
 async def create_ssh_instance_model(
     project: ProjectModel,
-    pool: PoolModel,
     instance_name: str,
     instance_num: int,
     internal_ip: Optional[str],
@@ -805,7 +499,6 @@ async def create_ssh_instance_model(
         name=instance_name,
         instance_num=instance_num,
         project=project,
-        pool=pool,
         backend=BackendType.REMOTE,
         created_at=common_utils.get_current_datetime(),
         started_at=common_utils.get_current_datetime(),

dstack/_internal/server/services/jobs/__init__.py

@@ -10,7 +10,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
 
 import dstack._internal.server.services.backends as backends_services
-from dstack._internal.core.backends.base import Backend
+from dstack._internal.core.backends.base.backend import Backend
+from dstack._internal.core.backends.base.compute import ComputeWithVolumeSupport
 from dstack._internal.core.consts import DSTACK_RUNNER_HTTP_PORT, DSTACK_SHIM_HTTP_PORT
 from dstack._internal.core.errors import (
     BackendError,
@@ -42,6 +43,7 @@ from dstack._internal.server.models import (
 )
 from dstack._internal.server.services import services
 from dstack._internal.server.services import volumes as volumes_services
+from dstack._internal.server.services.instances import get_instance_ssh_private_keys
 from dstack._internal.server.services.jobs.configurators.base import (
     JobConfigurator,
     interpolate_job_volumes,
@@ -50,7 +52,6 @@ from dstack._internal.server.services.jobs.configurators.dev import DevEnvironme
 from dstack._internal.server.services.jobs.configurators.service import ServiceJobConfigurator
 from dstack._internal.server.services.jobs.configurators.task import TaskJobConfigurator
 from dstack._internal.server.services.logging import fmt
-from dstack._internal.server.services.pools import get_instance_ssh_private_keys
 from dstack._internal.server.services.runner import client
 from dstack._internal.server.services.runner.ssh import runner_ssh_tunnel
 from dstack._internal.server.services.volumes import (
@@ -461,24 +462,26 @@ async def _detach_volume_from_job_instance(
     if volume.provisioning_data is None or not volume.provisioning_data.detachable:
         # Backends without `detach_volume` detach volumes automatically
         return detached
+    compute = backend.compute()
+    assert isinstance(compute, ComputeWithVolumeSupport)
     try:
         if job_model.volumes_detached_at is None:
             # We haven't tried detaching volumes yet, try soft detach first
             await run_async(
-                backend.compute().detach_volume,
+                compute.detach_volume,
                 volume=volume,
                 instance_id=jpd.instance_id,
                 force=False,
             )
             # For some backends, the volume may be detached immediately
             detached = await run_async(
-                backend.compute().is_volume_detached,
+                compute.is_volume_detached,
                 volume=volume,
                 instance_id=jpd.instance_id,
             )
         else:
             detached = await run_async(
-                backend.compute().is_volume_detached,
+                compute.is_volume_detached,
                 volume=volume,
                 instance_id=jpd.instance_id,
             )
@@ -489,7 +492,7 @@ async def _detach_volume_from_job_instance(
                     instance_model.name,
                 )
                 await run_async(
-                    backend.compute().detach_volume,
+                    compute.detach_volume,
                     volume=volume,
                     instance_id=jpd.instance_id,
                     force=True,

dstack/_internal/server/services/jobs/configurators/base.py

@@ -13,10 +13,15 @@ from dstack._internal.core.models.configurations import (
     PythonVersion,
     RunConfigurationType,
 )
-from dstack._internal.core.models.profiles import DEFAULT_STOP_DURATION, SpotPolicy
+from dstack._internal.core.models.profiles import (
+    DEFAULT_STOP_DURATION,
+    SpotPolicy,
+    UtilizationPolicy,
+)
 from dstack._internal.core.models.runs import (
     AppSpec,
     JobSpec,
+    JobSSHKey,
     Requirements,
     Retry,
     RunSpec,
@@ -26,6 +31,7 @@ from dstack._internal.core.models.volumes import MountPoint, VolumeMountPoint
 from dstack._internal.core.services.profiles import get_retry
 from dstack._internal.core.services.ssh.ports import filter_reserved_ports
 from dstack._internal.server.services.docker import ImageConfig, get_image_config
+from dstack._internal.utils import crypto
 from dstack._internal.utils.common import run_async
 from dstack._internal.utils.interpolator import InterpolatorError, VariablesInterpolator
 
@@ -53,6 +59,8 @@ class JobConfigurator(ABC):
     TYPE: RunConfigurationType
 
     _image_config: Optional[ImageConfig] = None
+    # JobSSHKey should be shared for all jobs in a replica for inter-node communitation.
+    _job_ssh_key: Optional[JobSSHKey] = None
 
     def __init__(self, run_spec: RunSpec):
         self.run_spec = run_spec
@@ -113,11 +121,13 @@ class JobConfigurator(ABC):
             single_branch=self._single_branch(),
             max_duration=self._max_duration(),
             stop_duration=self._stop_duration(),
+            utilization_policy=self._utilization_policy(),
             registry_auth=self._registry_auth(),
             requirements=self._requirements(),
             retry=self._retry(),
             working_dir=self._working_dir(),
             volumes=self._volumes(job_num),
+            ssh_key=self._ssh_key(jobs_per_replica),
         )
         return job_spec
 
@@ -201,6 +211,9 @@ class JobConfigurator(ABC):
         # pydantic validator ensures this is int
         return self.run_spec.merged_profile.stop_duration
 
+    def _utilization_policy(self) -> Optional[UtilizationPolicy]:
+        return self.run_spec.merged_profile.utilization_policy
+
     def _registry_auth(self) -> Optional[RegistryAuth]:
         return self.run_spec.configuration.registry_auth
 
@@ -230,6 +243,17 @@ class JobConfigurator(ABC):
     def _volumes(self, job_num: int) -> List[MountPoint]:
         return interpolate_job_volumes(self.run_spec.configuration.volumes, job_num)
 
+    def _ssh_key(self, jobs_per_replica: int) -> Optional[JobSSHKey]:
+        if jobs_per_replica < 2:
+            return None
+        if self._job_ssh_key is None:
+            private, public = crypto.generate_rsa_key_pair_bytes(comment="dstack_job")
+            self._job_ssh_key = JobSSHKey(
+                private=private.decode(),
+                public=public.decode(),
+            )
+        return self._job_ssh_key
+
 
 def interpolate_job_volumes(
     run_volumes: List[Union[MountPoint, str]],

dstack/_internal/server/services/jobs/configurators/dev.py

@@ -1,9 +1,11 @@
 from typing import List, Optional
 
+from dstack._internal.core.errors import ServerClientError
 from dstack._internal.core.models.configurations import PortMapping, RunConfigurationType
 from dstack._internal.core.models.profiles import SpotPolicy
 from dstack._internal.core.models.runs import RunSpec
 from dstack._internal.server.services.jobs.configurators.base import JobConfigurator
+from dstack._internal.server.services.jobs.configurators.extensions.cursor import CursorDesktop
 from dstack._internal.server.services.jobs.configurators.extensions.vscode import VSCodeDesktop
 
 INSTALL_IPYKERNEL = (
@@ -16,7 +18,13 @@ class DevEnvironmentJobConfigurator(JobConfigurator):
     TYPE: RunConfigurationType = RunConfigurationType.DEV_ENVIRONMENT
 
     def __init__(self, run_spec: RunSpec):
-        self.ide = VSCodeDesktop(
+        if run_spec.configuration.ide == "vscode":
+            __class = VSCodeDesktop
+        elif run_spec.configuration.ide == "cursor":
+            __class = CursorDesktop
+        else:
+            raise ServerClientError(f"Unsupported IDE: {run_spec.configuration.ide}")
+        self.ide = __class(
             run_name=run_spec.run_name,
             version=run_spec.configuration.version,
             extensions=["ms-python.python", "ms-toolsai.jupyter"],

dstack/_internal/server/services/jobs/configurators/extensions/cursor.py

@@ -0,0 +1,42 @@
+from typing import List
+
+
+class CursorDesktop:
+    def __init__(
+        self,
+        run_name: str,
+        version: str,
+        extensions: List[str],
+    ):
+        self.run_name = run_name
+        self.version = version
+        self.extensions = extensions
+
+    def get_install_commands(self) -> List[str]:
+        commands = []
+        if self.version is not None:
+            url = f"https://cursor.blob.core.windows.net/remote-releases/{self.version}/vscode-reh-linux-$arch.tar.gz"
+            archive = "vscode-reh-linux-$arch.tar.gz"
+            target = f'~/.cursor-server/cli/servers/"Stable-{self.version}"/server'
+            commands.extend(
+                [
+                    'if [ $(uname -m) = "aarch64" ]; then arch="arm64"; else arch="x64"; fi',
+                    "mkdir -p /tmp",
+                    f'wget -q --show-progress "{url}" -O "/tmp/{archive}"',
+                    f"mkdir -vp {target}",
+                    f'tar --no-same-owner -xz --strip-components=1 -C {target} -f "/tmp/{archive}"',
+                    f'rm "/tmp/{archive}"',
+                ]
+            )
+            if self.extensions:
+                extensions = " ".join(f'--install-extension "{name}"' for name in self.extensions)
+                commands.append(f'PATH="$PATH":{target}/bin cursor-server {extensions}')
+        return commands
+
+    def get_print_readme_commands(self) -> List[str]:
+        return [
+            "echo To open in VS Code Desktop, use link below:",
+            "echo ''",
+            f"echo '  cursor://vscode-remote/ssh-remote+{self.run_name}/workflow'",  # TODO use $REPO_DIR
+            "echo ''",
+        ]