dstack 0.19.26__py3-none-any.whl → 0.19.28__py3-none-any.whl

dstack/_internal/server/background/tasks/process_submitted_jobs.py

@@ -16,6 +16,7 @@ from dstack._internal.core.models.common import NetworkMode
 from dstack._internal.core.models.fleets import (
     Fleet,
     FleetConfiguration,
+    FleetNodesSpec,
     FleetSpec,
     FleetStatus,
     InstanceGroupPlacement,
@@ -26,7 +27,7 @@ from dstack._internal.core.models.profiles import (
     CreationPolicy,
     TerminationPolicy,
 )
-from dstack._internal.core.models.resources import Memory, Range
+from dstack._internal.core.models.resources import Memory
 from dstack._internal.core.models.runs import (
     Job,
     JobProvisioningData,
@@ -53,7 +54,9 @@ from dstack._internal.server.models import (
 from dstack._internal.server.services.backends import get_project_backend_by_type_or_error
 from dstack._internal.server.services.fleets import (
     fleet_model_to_fleet,
+    generate_fleet_name,
     get_fleet_requirements,
+    get_next_instance_num,
 )
 from dstack._internal.server.services.instances import (
     filter_pool_instances,
@@ -69,7 +72,7 @@ from dstack._internal.server.services.jobs import (
     get_job_configured_volumes,
     get_job_runtime_data,
 )
-from dstack._internal.server.services.locking import get_locker
+from dstack._internal.server.services.locking import get_locker, string_to_lock_id
 from dstack._internal.server.services.logging import fmt
 from dstack._internal.server.services.offers import get_offers_by_requirements
 from dstack._internal.server.services.requirements.combine import (
@@ -85,7 +88,6 @@ from dstack._internal.server.services.volumes import (
 )
 from dstack._internal.server.utils import sentry_utils
 from dstack._internal.utils import common as common_utils
-from dstack._internal.utils import env as env_utils
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -186,6 +188,7 @@ async def _process_submitted_job(session: AsyncSession, job_model: JobModel):
     run_spec = run.run_spec
     profile = run_spec.merged_profile
     job = find_job(run.jobs, job_model.replica_num, job_model.job_num)
+    multinode = job.job_spec.jobs_per_replica > 1
 
     # Master job chooses fleet for the run.
     # Due to two-step processing, it's saved to job_model.fleet.
@@ -308,6 +311,7 @@ async def _process_submitted_job(session: AsyncSession, job_model: JobModel):
                 session=session,
                 instances_with_offers=fleet_instances_with_offers,
                 job_model=job_model,
+                multinode=multinode,
             )
             job_model.fleet = fleet_model
             job_model.instance_assigned = True
@@ -361,7 +365,8 @@ async def _process_submitted_job(session: AsyncSession, job_model: JobModel):
         job_model.job_provisioning_data = job_provisioning_data.json()
         job_model.status = JobStatus.PROVISIONING
         if fleet_model is None:
-            fleet_model = _create_fleet_model_for_job(
+            fleet_model = await _create_fleet_model_for_job(
+                session=session,
                 project=project,
                 run=run,
             )
@@ -383,7 +388,9 @@ async def _process_submitted_job(session: AsyncSession, job_model: JobModel):
             offer=offer,
             instance_num=instance_num,
         )
-        job_model.job_runtime_data = _prepare_job_runtime_data(offer).json()
+        job_model.job_runtime_data = _prepare_job_runtime_data(offer, multinode).json()
+        # Both this task and process_fleets can add instances to fleets.
+        # TODO: Ensure this does not violate nodes.max when it's enforced.
         instance.fleet_id = fleet_model.id
         logger.info(
             "The job %s created the new instance %s",
@@ -610,6 +617,7 @@ async def _assign_job_to_fleet_instance(
     session: AsyncSession,
     instances_with_offers: list[tuple[InstanceModel, InstanceOfferWithAvailability]],
     job_model: JobModel,
+    multinode: bool,
 ) -> Optional[InstanceModel]:
     if len(instances_with_offers) == 0:
         return None
@@ -639,7 +647,7 @@ async def _assign_job_to_fleet_instance(
     job_model.instance = instance
     job_model.used_instance_id = instance.id
     job_model.job_provisioning_data = instance.job_provisioning_data
-    job_model.job_runtime_data = _prepare_job_runtime_data(offer).json()
+    job_model.job_runtime_data = _prepare_job_runtime_data(offer, multinode).json()
     return instance
 
 
@@ -748,26 +756,42 @@ def _check_can_create_new_instance_in_fleet(fleet: Fleet) -> bool:
     return True
 
 
-def _create_fleet_model_for_job(
+async def _create_fleet_model_for_job(
+    session: AsyncSession,
     project: ProjectModel,
     run: Run,
 ) -> FleetModel:
     placement = InstanceGroupPlacement.ANY
     if run.run_spec.configuration.type == "task" and run.run_spec.configuration.nodes > 1:
         placement = InstanceGroupPlacement.CLUSTER
+    nodes = _get_nodes_required_num_for_run(run.run_spec)
+
+    lock_namespace = f"fleet_names_{project.name}"
+    # TODO: Lock fleet names on SQLite.
+    # Needs some refactoring so that the lock is released after commit.
+    if get_db().dialect_name == "postgresql":
+        await session.execute(
+            select(func.pg_advisory_xact_lock(string_to_lock_id(lock_namespace)))
+        )
+    fleet_name = await generate_fleet_name(session=session, project=project)
+
     spec = FleetSpec(
         configuration=FleetConfiguration(
-            name=run.run_spec.run_name,
+            name=fleet_name,
             placement=placement,
             reservation=run.run_spec.configuration.reservation,
-            nodes=Range(min=_get_nodes_required_num_for_run(run.run_spec), max=None),
+            nodes=FleetNodesSpec(
+                min=nodes,
+                target=nodes,
+                max=None,
+            ),
         ),
         profile=run.run_spec.merged_profile,
         autocreated=True,
     )
     fleet_model = FleetModel(
         id=uuid.uuid4(),
-        name=run.run_spec.run_name,
+        name=fleet_name,
         project=project,
         status=FleetStatus.ACTIVE,
         spec=spec.json(),
@@ -778,10 +802,13 @@ def _create_fleet_model_for_job(
 
 async def _get_next_instance_num(session: AsyncSession, fleet_model: FleetModel) -> int:
     res = await session.execute(
-        select(func.count(InstanceModel.id)).where(InstanceModel.fleet_id == fleet_model.id)
+        select(InstanceModel.instance_num).where(
+            InstanceModel.fleet_id == fleet_model.id,
+            InstanceModel.deleted.is_(False),
+        )
     )
-    instance_count = res.scalar_one()
-    return instance_count
+    taken_instance_nums = set(res.scalars().all())
+    return get_next_instance_num(taken_instance_nums)
 
 
 def _create_instance_model_for_job(
@@ -827,12 +854,17 @@ def _create_instance_model_for_job(
     return instance
 
 
-def _prepare_job_runtime_data(offer: InstanceOfferWithAvailability) -> JobRuntimeData:
+def _prepare_job_runtime_data(
+    offer: InstanceOfferWithAvailability, multinode: bool
+) -> JobRuntimeData:
     if offer.blocks == offer.total_blocks:
-        if env_utils.get_bool("DSTACK_FORCE_BRIDGE_NETWORK"):
+        if settings.JOB_NETWORK_MODE == settings.JobNetworkMode.FORCED_BRIDGE:
             network_mode = NetworkMode.BRIDGE
-        else:
+        elif settings.JOB_NETWORK_MODE == settings.JobNetworkMode.HOST_WHEN_POSSIBLE:
             network_mode = NetworkMode.HOST
+        else:
+            assert settings.JOB_NETWORK_MODE == settings.JobNetworkMode.HOST_FOR_MULTINODE_ONLY
+            network_mode = NetworkMode.HOST if multinode else NetworkMode.BRIDGE
         return JobRuntimeData(
             network_mode=network_mode,
             offer=offer,

dstack/_internal/server/migrations/versions/2498ab323443_add_fleetmodel_consolidation_attempt_.py

@@ -0,0 +1,44 @@
+"""Add FleetModel.consolidation_attempt and FleetModel.last_consolidated_at
+
+Revision ID: 2498ab323443
+Revises: e2d08cd1b8d9
+Create Date: 2025-08-29 16:08:48.686595
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+import dstack._internal.server.models
+
+# revision identifiers, used by Alembic.
+revision = "2498ab323443"
+down_revision = "e2d08cd1b8d9"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("fleets", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("consolidation_attempt", sa.Integer(), server_default="0", nullable=False)
+        )
+        batch_op.add_column(
+            sa.Column(
+                "last_consolidated_at",
+                dstack._internal.server.models.NaiveDateTime(),
+                nullable=True,
+            )
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("fleets", schema=None) as batch_op:
+        batch_op.drop_column("last_consolidated_at")
+        batch_op.drop_column("consolidation_attempt")
+
+    # ### end Alembic commands ###

dstack/_internal/server/models.py

@@ -24,7 +24,7 @@ from sqlalchemy_utils import UUIDType
 
 from dstack._internal.core.errors import DstackError
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import CoreModel
+from dstack._internal.core.models.common import CoreConfig, generate_dual_core_model
 from dstack._internal.core.models.fleets import FleetStatus
 from dstack._internal.core.models.gateways import GatewayStatus
 from dstack._internal.core.models.health import HealthStatus
@@ -71,7 +71,11 @@ class NaiveDateTime(TypeDecorator):
         return value.replace(tzinfo=timezone.utc)
 
 
-class DecryptedString(CoreModel):
+class DecryptedStringConfig(CoreConfig):
+    arbitrary_types_allowed = True
+
+
+class DecryptedString(generate_dual_core_model(DecryptedStringConfig)):
     """
     A type for representing plaintext strings encrypted with `EncryptedString`.
     Besides the string, stores information if the decryption was successful.
@@ -84,9 +88,6 @@ class DecryptedString(CoreModel):
     decrypted: bool = True
     exc: Optional[Exception] = None
 
-    class Config(CoreModel.Config):
-        arbitrary_types_allowed = True
-
     def get_plaintext_or_error(self) -> str:
         if self.decrypted and self.plaintext is not None:
             return self.plaintext
@@ -551,6 +552,9 @@ class FleetModel(BaseModel):
     jobs: Mapped[List["JobModel"]] = relationship(back_populates="fleet")
     instances: Mapped[List["InstanceModel"]] = relationship(back_populates="fleet")
 
+    consolidation_attempt: Mapped[int] = mapped_column(Integer, server_default="0")
+    last_consolidated_at: Mapped[Optional[datetime]] = mapped_column(NaiveDateTime)
+
 
 class InstanceModel(BaseModel):
     __tablename__ = "instances"
@@ -605,8 +609,8 @@ class InstanceModel(BaseModel):
         Integer, default=DEFAULT_FLEET_TERMINATION_IDLE_TIME
     )
 
-    # retry policy
-    last_retry_at: Mapped[Optional[datetime]] = mapped_column(NaiveDateTime)
+    # Deprecated
+    last_retry_at: Mapped[Optional[datetime]] = mapped_column(NaiveDateTime, deferred=True)
 
     # instance termination handling
     termination_deadline: Mapped[Optional[datetime]] = mapped_column(NaiveDateTime)

dstack/_internal/server/schemas/gateways.py

@@ -3,24 +3,25 @@ from typing import Annotated, Any, Dict, List, Optional
 from pydantic import Field
 
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.common import CoreModel
+from dstack._internal.core.models.common import CoreConfig, CoreModel, generate_dual_core_model
 from dstack._internal.core.models.gateways import GatewayConfiguration
 
 
-class CreateGatewayRequest(CoreModel):
+class CreateGatewayRequestConfig(CoreConfig):
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any]):
+        del schema["properties"]["name"]
+        del schema["properties"]["backend_type"]
+        del schema["properties"]["region"]
+
+
+class CreateGatewayRequest(generate_dual_core_model(CreateGatewayRequestConfig)):
     configuration: GatewayConfiguration
     # Deprecated and unused. Left for compatibility with 0.18 clients.
     name: Annotated[Optional[str], Field(exclude=True)] = None
     backend_type: Annotated[Optional[BackendType], Field(exclude=True)] = None
     region: Annotated[Optional[str], Field(exclude=True)] = None
 
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]) -> None:
-            del schema["properties"]["name"]
-            del schema["properties"]["backend_type"]
-            del schema["properties"]["region"]
-
 
 class GetGatewayRequest(CoreModel):
     name: str

dstack/_internal/server/schemas/runner.py

@@ -78,6 +78,7 @@ class SubmitBody(CoreModel):
                 "max_duration",
                 "ssh_key",
                 "working_dir",
+                "repo_dir",
                 "repo_data",
                 "file_archives",
             }

dstack/_internal/server/services/backends/handlers.py

@@ -20,6 +20,8 @@ async def delete_backends_safe(
     error: bool = True,
 ):
     try:
+        # FIXME: The checks are not under lock,
+        # so there can be dangling active resources due to race conditions.
         await _check_active_instances(
             session=session,
             project=project,

dstack/_internal/server/services/docker.py

@@ -9,7 +9,11 @@ from pydantic import Field, ValidationError, validator
 from typing_extensions import Annotated
 
 from dstack._internal.core.errors import DockerRegistryError
-from dstack._internal.core.models.common import CoreModel, RegistryAuth
+from dstack._internal.core.models.common import (
+    CoreModel,
+    FrozenCoreModel,
+    RegistryAuth,
+)
 from dstack._internal.server.utils.common import join_byte_stream_checked
 from dstack._internal.utils.dxf import PatchedDXF
 
@@ -31,15 +35,12 @@ class DXFAuthAdapter:
         )
 
 
-class DockerImage(CoreModel):
+class DockerImage(FrozenCoreModel):
     image: str
-    registry: Optional[str]
+    registry: Optional[str] = None
     repo: str
     tag: str
-    digest: Optional[str]
-
-    class Config(CoreModel.Config):
-        frozen = True
+    digest: Optional[str] = None
 
 
 class ImageConfig(CoreModel):

dstack/_internal/server/services/fleets.py

@@ -449,25 +449,24 @@ async def create_fleet(
     return await _create_fleet(session=session, project=project, user=user, spec=spec)
 
 
-async def create_fleet_instance_model(
+def create_fleet_instance_model(
     session: AsyncSession,
     project: ProjectModel,
-    user: UserModel,
+    username: str,
     spec: FleetSpec,
-    reservation: Optional[str],
     instance_num: int,
 ) -> InstanceModel:
     profile = spec.merged_profile
     requirements = get_fleet_requirements(spec)
-    instance_model = await instances_services.create_instance_model(
+    instance_model = instances_services.create_instance_model(
         session=session,
         project=project,
-        user=user,
+        username=username,
         profile=profile,
         requirements=requirements,
         instance_name=f"{spec.configuration.name}-{instance_num}",
         instance_num=instance_num,
-        reservation=reservation,
+        reservation=spec.merged_profile.reservation,
         blocks=spec.configuration.blocks,
         tags=spec.configuration.tags,
     )
@@ -655,6 +654,19 @@ def get_fleet_requirements(fleet_spec: FleetSpec) -> Requirements:
     return requirements
 
 
+def get_next_instance_num(taken_instance_nums: set[int]) -> int:
+    if not taken_instance_nums:
+        return 0
+    min_instance_num = min(taken_instance_nums)
+    if min_instance_num > 0:
+        return 0
+    instance_num = min_instance_num + 1
+    while True:
+        if instance_num not in taken_instance_nums:
+            return instance_num
+        instance_num += 1
+
+
 async def _create_fleet(
     session: AsyncSession,
     project: ProjectModel,
@@ -705,12 +717,11 @@ async def _create_fleet(
                 fleet_model.instances.append(instances_model)
         else:
             for i in range(_get_fleet_nodes_to_provision(spec)):
-                instance_model = await create_fleet_instance_model(
+                instance_model = create_fleet_instance_model(
                     session=session,
                     project=project,
-                    user=user,
+                    username=user.name,
                     spec=spec,
-                    reservation=spec.configuration.reservation,
                     instance_num=i,
                 )
                 fleet_model.instances.append(instance_model)
@@ -778,7 +789,7 @@ async def _update_fleet(
         if added_hosts:
             await _check_ssh_hosts_not_yet_added(session, spec, fleet.id)
             for host in added_hosts.values():
-                instance_num = _get_next_instance_num(active_instance_nums)
+                instance_num = get_next_instance_num(active_instance_nums)
                 instance_model = await create_fleet_ssh_instance_model(
                     project=project,
                     spec=spec,
@@ -994,9 +1005,9 @@ def _validate_internal_ips(ssh_config: SSHParams):
 
 
 def _get_fleet_nodes_to_provision(spec: FleetSpec) -> int:
-    if spec.configuration.nodes is None or spec.configuration.nodes.min is None:
+    if spec.configuration.nodes is None:
         return 0
-    return spec.configuration.nodes.min
+    return spec.configuration.nodes.target
 
 
 def _terminate_fleet_instances(fleet_model: FleetModel, instance_nums: Optional[List[int]]):
@@ -1013,16 +1024,3 @@ def _terminate_fleet_instances(fleet_model: FleetModel, instance_nums: Optional[
             instance.deleted = True
         else:
             instance.status = InstanceStatus.TERMINATING
-
-
-def _get_next_instance_num(instance_nums: set[int]) -> int:
-    if not instance_nums:
-        return 0
-    min_instance_num = min(instance_nums)
-    if min_instance_num > 0:
-        return 0
-    instance_num = min_instance_num + 1
-    while True:
-        if instance_num not in instance_nums:
-            return instance_num
-        instance_num += 1

dstack/_internal/server/services/instances.py

@@ -513,10 +513,10 @@ async def list_active_remote_instances(
     return instance_models
 
 
-async def create_instance_model(
+def create_instance_model(
     session: AsyncSession,
     project: ProjectModel,
-    user: UserModel,
+    username: str,
     profile: Profile,
     requirements: Requirements,
     instance_name: str,
@@ -536,7 +536,7 @@ async def create_instance_model(
     instance_config = InstanceConfiguration(
         project_name=project.name,
         instance_name=instance_name,
-        user=user.name,
+        user=username,
         ssh_keys=[project_ssh_key],
         instance_id=str(instance_id),
         reservation=reservation,

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

@@ -16,7 +16,7 @@ from dstack._internal.core.models.configurations import (
     DEFAULT_PROBE_READY_AFTER,
     DEFAULT_PROBE_TIMEOUT,
     DEFAULT_PROBE_URL,
-    DEFAULT_REPO_DIR,
+    LEGACY_REPO_DIR,
     PortMapping,
     ProbeConfig,
     PythonVersion,
@@ -45,6 +45,14 @@ from dstack._internal.server.services.docker import ImageConfig, get_image_confi
 from dstack._internal.utils import crypto
 from dstack._internal.utils.common import run_async
 from dstack._internal.utils.interpolator import InterpolatorError, VariablesInterpolator
+from dstack._internal.utils.logging import get_logger
+from dstack._internal.utils.path import is_absolute_posix_path
+
+logger = get_logger(__name__)
+
+
+DSTACK_DIR = "/dstack"
+DSTACK_PROFILE_PATH = f"{DSTACK_DIR}/profile"
 
 
 def get_default_python_verison() -> str:
@@ -160,6 +168,7 @@ class JobConfigurator(ABC):
             ssh_key=self._ssh_key(jobs_per_replica),
             repo_data=self.run_spec.repo_data,
             repo_code_hash=self.run_spec.repo_code_hash,
+            repo_dir=self._repo_dir(),
             file_archives=self.run_spec.file_archives,
             service_port=self._service_port(),
             probes=self._probes(),
@@ -209,9 +218,17 @@ class JobConfigurator(ABC):
         ):
             return []
         return [
-            f"uv venv --python {self._python()} --prompt workflow --seed {DEFAULT_REPO_DIR}/.venv > /dev/null 2>&1",
-            f"echo 'source {DEFAULT_REPO_DIR}/.venv/bin/activate' >> ~/.bashrc",
-            f"source {DEFAULT_REPO_DIR}/.venv/bin/activate",
+            # `uv` may emit:
+            # > warning: `VIRTUAL_ENV=/dstack/venv` does not match the project environment path
+            # > `.venv` and will be ignored; use `--active` to target the active environment
+            # > instead
+            # Safe to ignore, reusing dstack's venv for `uv` is discouraged (it should only be
+            # used for legacy `pip`-based configurations). `--no-active` suppresses the warning.
+            # Alternatively, the user can call `deactivate` once before using `uv`.
+            # If the user really wants to reuse dstack's venv, they must spefify `--active`.
+            f"uv venv -q --prompt dstack -p {self._python()} --seed {DSTACK_DIR}/venv",
+            f"echo '. {DSTACK_DIR}/venv/bin/activate' >> {DSTACK_PROFILE_PATH}",
+            f". {DSTACK_DIR}/venv/bin/activate",
         ]
 
     def _app_specs(self) -> List[AppSpec]:
@@ -290,11 +307,34 @@ class JobConfigurator(ABC):
     def _retry(self) -> Optional[Retry]:
         return get_retry(self.run_spec.merged_profile)
 
+    def _repo_dir(self) -> str:
+        """
+        Returns absolute or relative path
+        """
+        repo_dir = self.run_spec.repo_dir
+        if repo_dir is None:
+            return LEGACY_REPO_DIR
+        return repo_dir
+
     def _working_dir(self) -> Optional[str]:
         """
-        None means default working directory
+        Returns path or None
+
+        None means the default working directory taken from the image
+
+        Currently, for compatibility with pre-0.19.27 runners, the path may be relative.
+        Future versions should return only absolute paths
         """
-        return self.run_spec.working_dir
+        working_dir = self.run_spec.configuration.working_dir
+        if working_dir is None:
+            return working_dir
+        # Return a relative path if possible
+        if is_absolute_posix_path(working_dir):
+            try:
+                return str(PurePosixPath(working_dir).relative_to(LEGACY_REPO_DIR))
+            except ValueError:
+                pass
+        return working_dir
 
     def _python(self) -> str:
         if self.run_spec.configuration.python is not None:

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

@@ -9,8 +9,8 @@ from dstack._internal.server.services.jobs.configurators.extensions.cursor impor
 from dstack._internal.server.services.jobs.configurators.extensions.vscode import VSCodeDesktop
 
 INSTALL_IPYKERNEL = (
-    "(echo pip install ipykernel... && pip install -q --no-cache-dir ipykernel 2> /dev/null) || "
-    'echo "no pip, ipykernel was not installed"'
+    "(echo 'pip install ipykernel...' && pip install -q --no-cache-dir ipykernel 2> /dev/null) || "
+    "echo 'no pip, ipykernel was not installed'"
 )
 
 
@@ -39,12 +39,12 @@ class DevEnvironmentJobConfigurator(JobConfigurator):
         commands = self.ide.get_install_commands()
         commands.append(INSTALL_IPYKERNEL)
         commands += self.run_spec.configuration.setup
-        commands.append("echo ''")
+        commands.append("echo")
         commands += self.run_spec.configuration.init
         commands += self.ide.get_print_readme_commands()
         commands += [
             f"echo 'To connect via SSH, use: `ssh {self.run_spec.run_name}`'",
-            "echo ''",
+            "echo",
             "echo -n 'To exit, press Ctrl+C.'",
         ]
         commands += ["tail -f /dev/null"]  # idle

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

@@ -1,7 +1,5 @@
 from typing import List, Optional
 
-from dstack._internal.core.models.configurations import DEFAULT_REPO_DIR
-
 
 class CursorDesktop:
     def __init__(
@@ -38,7 +36,7 @@ class CursorDesktop:
     def get_print_readme_commands(self) -> List[str]:
         return [
             "echo To open in Cursor, use link below:",
-            "echo ''",
-            f"echo '  cursor://vscode-remote/ssh-remote+{self.run_name}{DEFAULT_REPO_DIR}'",  # TODO use $REPO_DIR
-            "echo ''",
+            "echo",
+            f'echo "  cursor://vscode-remote/ssh-remote+{self.run_name}$DSTACK_REPO_DIR"',
+            "echo",
         ]

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

@@ -1,7 +1,5 @@
 from typing import List, Optional
 
-from dstack._internal.core.models.configurations import DEFAULT_REPO_DIR
-
 
 class VSCodeDesktop:
     def __init__(
@@ -37,8 +35,8 @@ class VSCodeDesktop:
 
     def get_print_readme_commands(self) -> List[str]:
         return [
-            "echo To open in VS Code Desktop, use link below:",
-            "echo ''",
-            f"echo '  vscode://vscode-remote/ssh-remote+{self.run_name}{DEFAULT_REPO_DIR}'",  # TODO use $REPO_DIR
-            "echo ''",
+            "echo 'To open in VS Code Desktop, use link below:'",
+            "echo",
+            f'echo "  vscode://vscode-remote/ssh-remote+{self.run_name}$DSTACK_REPO_DIR"',
+            "echo",
         ]

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

@@ -23,6 +23,3 @@ class ServiceJobConfigurator(JobConfigurator):
 
     def _ports(self) -> List[PortMapping]:
         return []
-
-    def _working_dir(self) -> Optional[str]:
-        return None if not self._shell_commands() else super()._working_dir()

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

@@ -37,6 +37,3 @@ class TaskJobConfigurator(JobConfigurator):
     def _ports(self) -> List[PortMapping]:
         assert self.run_spec.configuration.type == "task"
         return self.run_spec.configuration.ports
-
-    def _working_dir(self) -> Optional[str]:
-        return None if not self._shell_commands() else super()._working_dir()