@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/devContainerAgentHostService.js

@@ -2,16 +2,17 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { raceCancellationError, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { SequencerByKey, raceCancellationError, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import { Disposable, DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, combinedDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { findDevContainerSample } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/devContainerSamples';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { agentHostAuthority, AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { agentsWindowAgentHostClientInfo } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostClientInfo';
 import { AgentHostProtocolClient } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostProtocolClient';
 import { RemoteAgentHostEntryType, getEntryTypeConfig, RemoteAgentHostConnectionStatus, getEntryAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
@@ -20,20 +21,43 @@ import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { resolveRemoteAgentHostEntryAuthority } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/openInVSCodeUtils';
+import { devContainerSourcePath, getDevContainerSourceEntry, resolveDevContainerSourceConnection } from './devContainerSource.js';
 import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+import { waitForState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utilsCancellation';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 const DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY = "devContainerAgentHost.connections";
 const CONNECTOR_REGISTRATION_TIMEOUT_MS = 30_000;
 function isStoredDevContainerAgentHost(value) {
-    return typeof value === "object" && value !== null && typeof Reflect.get(value, "workspaceUri") === "string" && typeof Reflect.get(value, "name") === "string";
+    return typeof value === "object" && value !== null && typeof Reflect.get(value, "workspaceUri") === "string" && typeof Reflect.get(value, "name") === "string" && (Reflect.get(value, "sandboxEnabled") === undefined || typeof Reflect.get(value, "sandboxEnabled") === "boolean");
 }
 function devContainerAddress(workspaceUri) {
     const sha = ( new StringSHA1());
     sha.update(getComparisonKey(workspaceUri));
     return `devcontainer:${sha.digest()}`;
 }
+async function createDevContainerConnection(connector, workspaceUri, address, token, options) {
+    const key = getComparisonKey(workspaceUri);
+    let inspectedSupport;
+    const listener = connector.onDidChangeSandboxSupport?.(event => {
+        if (getComparisonKey(event.workspaceUri) === key) {
+            inspectedSupport = event.supported;
+        }
+    });
+    try {
+        const connection = await connector.createConnection(workspaceUri, address, token, options);
+        return inspectedSupport !== undefined ? {
+            ...connection,
+            sandboxSupported: inspectedSupport
+        } : connection;
+    } finally {
+        listener?.dispose();
+    }
+}
 class DevContainerConnectionFactory extends Disposable {
     constructor(_instantiationService) {
         super();
@@ -43,20 +67,29 @@ class DevContainerConnectionFactory extends Disposable {
         this._entries = observableValue(this, []);
         this.entries = this._entries;
     }
-    stageConnection(connector, workspaceUri, connection) {
+    stageConnection(connector, workspaceUri, connection, hostAuthority, sandboxEnabled) {
         const entry = {
             name: connection.name,
             connection: {
                 type: RemoteAgentHostEntryType.DevContainer,
                 address: connection.address,
-                hostPath: workspaceUri.fsPath
+                ...(connection.repository ? {
+                    repository: connection.repository
+                } : {
+                    hostPath: connection.hostWorkspaceFolder ?? devContainerSourcePath(workspaceUri)
+                }),
+                ...(hostAuthority ? {
+                    hostAuthority
+                } : {})
             }
         };
         this._stagedConnections.set(connection.address, {
             entry,
             connector,
             workspaceUri,
-            initialConnection: connection
+            initialConnection: connection,
+            sandboxEnabled,
+            sandboxSupported: connection.sandboxSupported
         });
         this._updateEntries();
         return entry;
@@ -67,7 +100,18 @@ class DevContainerConnectionFactory extends Disposable {
         staged?.initialConnection?.transportDisposable?.dispose();
         this._updateEntries();
     }
-    async createConnection(entry, _options) {
+    getSandboxSupported(address) {
+        return this._stagedConnections.get(address)?.sandboxSupported;
+    }
+    setSandboxSupported(workspaceUri, supported) {
+        const key = getComparisonKey(workspaceUri);
+        for (const staged of ( this._stagedConnections.values())) {
+            if (getComparisonKey(staged.workspaceUri) === key) {
+                staged.sandboxSupported = supported;
+            }
+        }
+    }
+    async createConnection(entry, options) {
         if (entry.connection.type !== RemoteAgentHostEntryType.DevContainer) {
             throw ( new Error(
                 `Dev Container factory cannot create a ${entry.connection.type} connection.`
@@ -77,12 +121,23 @@ class DevContainerConnectionFactory extends Disposable {
         if (!staged) {
             throw ( new Error(`No Dev Container connection is staged for ${entry.connection.address}.`));
         }
-        const connection = staged.initialConnection ?? (await staged.connector.createConnection(staged.workspaceUri, entry.connection.address, CancellationToken.None));
+        const connection = staged.initialConnection ?? (await createDevContainerConnection(
+            staged.connector,
+            staged.workspaceUri,
+            entry.connection.address,
+            CancellationToken.None,
+            {
+                resume: options.userInitiated,
+                ...(staged.sandboxEnabled !== undefined ? {
+                    sandboxEnabled: staged.sandboxEnabled
+                } : {})
+            }
+        ));
         try {
             const authority = agentHostAuthority(entry.connection.address);
             if (connection.workspaceUri.scheme !== AGENT_HOST_SCHEME || connection.workspaceUri.authority !== authority) {
                 throw ( new Error(( localize(
-                    4385,
+                    5299,
                     "Dev Container workspace URI must use the '{0}' scheme and '{1}' authority.",
                     AGENT_HOST_SCHEME,
                     authority
@@ -98,6 +153,7 @@ class DevContainerConnectionFactory extends Disposable {
                 }
             );
             staged.initialConnection = undefined;
+            staged.sandboxSupported = connection.sandboxSupported;
             return {
                 connection: client,
                 transportDisposable: connection.transportDisposable
@@ -119,18 +175,23 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         _instantiationService,
         _remoteAgentHostService,
         _sessionsProvidersService,
-        _storageService
+        _storageService,
+        _workspaceTrustRequestService
     ) {
         super();
         this._instantiationService = _instantiationService;
         this._remoteAgentHostService = _remoteAgentHostService;
         this._sessionsProvidersService = _sessionsProvidersService;
         this._storageService = _storageService;
+        this._workspaceTrustRequestService = _workspaceTrustRequestService;
         this._providerStores = this._register(( new DisposableMap()));
         this._providers = ( new Map());
         this._activeConnections = ( new Map());
+        this._knownSandboxSupport = ( new Map());
         this._pendingConnections = ( new Map());
         this._storedConnections = ( new Map());
+        this._lifecycleOperations = ( new SequencerByKey());
+        this._lifecycleTokenSource = this._register(( new CancellationTokenSource()));
         this._onDidRegisterConnector = this._register(( new Emitter()));
         this._onDidChangeAvailability = this._register(( new Emitter()));
         this.onDidChangeAvailability = this._onDidChangeAvailability.event;
@@ -141,38 +202,91 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         this._register(
             this._remoteAgentHostService.onDidChangeConnections(() => this._reconcileConnections())
         );
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._onDidChangeAvailability.fire())
+        );
+        this._register(
+            this._sessionsProvidersService.onDidChangeProviders(() => this._initializeProviders())
+        );
         this._restoreProviders();
+        this._initializeProviders();
         this._register(this._storageService.onDidChangeValue(
             StorageScope.APPLICATION,
             DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY,
             this._store
         )(() => this._restoreProviders()));
     }
+    _initializeProviders() {
+        for (const provider of this._sessionsProvidersService.getProviders()) {
+            if (provider instanceof RemoteAgentHostSessionsProvider) {
+                provider.initializeDevContainerSupport(this, this._sessionsProvidersService, this._workspaceTrustRequestService);
+            }
+        }
+    }
     registerConnector(connector) {
         if (this._connector) {
-            throw ( new Error(( localize(4386, "A Dev Container Agent Host connector is already registered."))));
+            throw ( new Error(( localize(5300, "A Dev Container Agent Host connector is already registered."))));
         }
         this._connector = connector;
+        const sandboxSupportListener = connector.onDidChangeSandboxSupport?.(event => this._setSandboxSupported(event.workspaceUri, event.supported));
         this._onDidRegisterConnector.fire(connector);
         this._onDidChangeAvailability.fire();
-        return toDisposable(() => {
+        return combinedDisposable(sandboxSupportListener ?? Disposable.None, toDisposable(() => {
             if (this._connector === connector) {
                 this._connector = undefined;
                 this._onDidChangeAvailability.fire();
             }
-        });
+        }));
     }
     isAvailable(workspaceUri) {
         return this._connector?.isAvailable(workspaceUri) ?? Promise.resolve(false);
     }
-    connect(workspaceUri, token) {
-        return this._ensureConnection(workspaceUri, token).then(active => this._acquireConnection(getComparisonKey(workspaceUri), active));
+    getSandboxSupported(workspaceUri) {
+        return this._knownSandboxSupport.get(getComparisonKey(workspaceUri));
     }
-    _ensureConnection(workspaceUri, token) {
+    _setSandboxSupported(workspaceUri, supported) {
         const key = getComparisonKey(workspaceUri);
+        const previous = this._knownSandboxSupport.get(key);
+        if (supported === undefined) {
+            this._knownSandboxSupport.delete(key);
+        } else {
+            this._knownSandboxSupport.set(key, supported);
+        }
+        this._connectionFactory.setSandboxSupported(workspaceUri, supported);
         const active = this._activeConnections.get(key);
-        if (active && this._isConnectedOrReconnecting(active.address)) {
-            return Promise.resolve(active);
+        if (active) {
+            active.sandboxSupported = supported;
+        }
+        this._providers.get(key)?.setDevContainerSandboxSupported(supported);
+        if (previous !== supported) {
+            this._onDidChangeAvailability.fire();
+        }
+    }
+    async connect(workspaceUri, token, options) {
+        const key = getComparisonKey(workspaceUri);
+        const active = this._activeConnections.get(key);
+        const target = active && this._acquireConnection(key, active);
+        try {
+            const connected = await this._ensureConnection(workspaceUri, token, options?.sandboxEnabled);
+            return target ?? this._acquireConnection(key, connected);
+        } catch (error) {
+            await target?.release();
+            throw error;
+        }
+    }
+    async showLog(workspaceUri) {
+        const connector = this._connector ?? (await this._waitForConnector(CancellationToken.None));
+        await connector.showLog(workspaceUri);
+    }
+    _ensureConnection(workspaceUri, token, sandboxEnabled) {
+        const key = getComparisonKey(workspaceUri);
+        sandboxEnabled ??= this._storedConnections.get(key)?.sandboxEnabled;
+        const active = this._activeConnections.get(key);
+        if (active) {
+            if (active.state === "running" && this._isConnectedOrReconnecting(active.address)) {
+                return this._waitForReconnection(active, token);
+            }
+            return raceCancellationError(this._ensureActiveConnection(key, active, sandboxEnabled), token).then(() => active);
         }
         const pending = this._pendingConnections.get(key);
         if (pending) {
@@ -180,7 +294,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         }
         this._providers.get(key)?.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
         const tokenSource = ( new CancellationTokenSource(token));
-        const promise = this._replaceConnectionAndConnect(workspaceUri, key, active, tokenSource.token);
+        const promise = this._connectWhenReady(workspaceUri, key, tokenSource.token, sandboxEnabled);
         const pendingConnection = {
             promise,
             tokenSource
@@ -192,6 +306,30 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         );
         return promise;
     }
+    async _waitForReconnection(active, token) {
+        const {
+            connection,
+            canceled
+        } = await waitForState(observableFromEvent(this, Event.any(
+            this._remoteAgentHostService.onDidChangeConnections,
+            listener => token.onCancellationRequested(listener)
+        ), () => ({
+            connection: this._remoteAgentHostService.connections.find(connection => connection.address === active.address),
+            canceled: token.isCancellationRequested
+        })), (
+            {
+                connection,
+                canceled
+            }
+        ) => canceled || !connection || (!RemoteAgentHostConnectionStatus.isReconnecting(connection.status) && !RemoteAgentHostConnectionStatus.isConnecting(connection.status)));
+        if (canceled) {
+            throw ( new CancellationError());
+        }
+        if (!connection || !RemoteAgentHostConnectionStatus.isConnected(connection.status)) {
+            throw ( new Error(( localize(5301, "The Dev Container Agent Host disconnected while reconnecting."))));
+        }
+        return active;
+    }
     _completePendingConnection(key, pending) {
         if (this._pendingConnections.get(key) === pending) {
             this._pendingConnections.delete(key);
@@ -201,30 +339,32 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         }
         pending.tokenSource.dispose();
     }
-    async _replaceConnectionAndConnect(workspaceUri, key, active, token) {
+    async _connectWhenReady(workspaceUri, key, token, sandboxEnabled) {
         const connector = this._connector ?? (await this._waitForConnector(token));
-        if (active) {
-            await this._disconnectActiveConnection(key, active);
-        }
-        return this._connect(connector, workspaceUri, key, token);
+        return this._connect(connector, workspaceUri, key, token, sandboxEnabled);
     }
     async _waitForConnector(token) {
         const connectorPromise = Event.toPromise(this._onDidRegisterConnector.event);
         try {
             const connector = await raceCancellationError(raceTimeout(connectorPromise, CONNECTOR_REGISTRATION_TIMEOUT_MS), token);
             if (!connector) {
-                throw ( new Error(( localize(4387, "No Dev Container Agent Host connector is registered."))));
+                throw ( new Error(( localize(5302, "No Dev Container Agent Host connector is registered."))));
             }
             return connector;
         } finally {
             connectorPromise.cancel();
         }
     }
-    async _connect(connector, workspaceUri, key, token) {
+    async _connect(connector, workspaceUri, key, token, sandboxEnabled) {
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
-        const connected = await connector.createConnection(workspaceUri, devContainerAddress(workspaceUri), token);
+        const connected = await createDevContainerConnection(connector, workspaceUri, devContainerAddress(workspaceUri), token, {
+            resume: true,
+            ...(sandboxEnabled !== undefined ? {
+                sandboxEnabled
+            } : {})
+        });
         if (token.isCancellationRequested) {
             connected.transportDisposable?.dispose();
             throw ( new CancellationError());
@@ -232,7 +372,15 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         let stagedAddress;
         try {
             const provider = this._ensureProvider(workspaceUri, connected.name, connected.address);
-            const entry = this._connectionFactory.stageConnection(connector, workspaceUri, connected);
+            this._setSandboxSupported(workspaceUri, connected.sandboxSupported);
+            const sourceEntry = getDevContainerSourceEntry(workspaceUri, this._remoteAgentHostService);
+            const entry = this._connectionFactory.stageConnection(
+                connector,
+                workspaceUri,
+                connected,
+                sourceEntry && resolveRemoteAgentHostEntryAuthority(sourceEntry),
+                sandboxEnabled
+            );
             const address = getEntryAddress(entry);
             stagedAddress = address;
             if (token.isCancellationRequested) {
@@ -243,7 +391,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             const connection = this._remoteAgentHostService.getConnection(connectionInfo.address);
             if (!connection) {
                 throw ( new Error(( localize(
-                    4388,
+                    5303,
                     "Dev Container Agent Host connection was not available after connecting."
                 ))));
             }
@@ -251,7 +399,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             provider.setConnectionStatus(connectionInfo.status);
             await this._waitForSessionTypes(provider, token);
             if (provider.getSessions().length > 0) {
-                this._storeConnection(workspaceUri, connected.name);
+                this._storeConnection(workspaceUri, connected.name, sandboxEnabled);
             }
             const target = {
                 providerId: provider.id,
@@ -261,9 +409,15 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
                 address,
                 provider,
                 target,
-                references: 0
+                connector,
+                workspaceUri,
+                state: "running",
+                references: 0,
+                sandboxEnabled,
+                sandboxSupported: this.getSandboxSupported(workspaceUri)
             };
             this._activeConnections.set(key, active);
+            this._onDidChangeAvailability.fire();
             return active;
         } catch (error) {
             if (stagedAddress !== undefined) {
@@ -293,6 +447,9 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
                 released = true;
                 active.references--;
                 if (active.references === 0 && this._activeConnections.get(key) === active) {
+                    if (active.connector.stopContainer) {
+                        return;
+                    }
                     await this._disconnectActiveConnection(key, active);
                     if (active.provider.getSessions().length === 0) {
                         this._removeStoredConnection(key);
@@ -309,15 +466,29 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             return existing;
         }
         const store = ( new DisposableStore());
+        const connectOnDemand = async () => {
+            await this._ensureConnection(workspaceUri, CancellationToken.None);
+        };
         const provider = store.add(this._createProvider({
             address,
             name,
-            devContainerWorktreeScope: key,
+            devContainerSourceWorkspaceUri: workspaceUri,
+            devContainerWorktreeScope: findDevContainerSample(workspaceUri) ? undefined : getComparisonKey(fromAgentHostUri(workspaceUri)),
+            resolveDevContainerWorktreeConnection: workspaceUri.scheme === AGENT_HOST_SCHEME ? () => resolveDevContainerSourceConnection(
+                workspaceUri,
+                this._remoteAgentHostService,
+                this._sessionsProvidersService,
+                CancellationToken.None
+            ) : undefined,
             omitHostFromWorkspaceLabel: true,
-            connectOnDemand: async () => {
-                await this._ensureConnection(workspaceUri, CancellationToken.None);
+            devContainerLifecycle: {
+                connect: connectOnDemand,
+                stop: () => this._stopContainer(key),
+                remove: () => this._removeContainer(key)
             },
-            disconnectOnDemand: () => this.disconnect(workspaceUri)
+            connectOnDemand,
+            disconnectOnDemand: () => this.disconnect(workspaceUri),
+            showConnectionLog: () => this.showLog(workspaceUri)
         }));
         provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
         store.add(this._sessionsProvidersService.registerProvider(provider));
@@ -326,7 +497,11 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
                 this._storeConnection(workspaceUri, name);
             }
         }));
-        store.add(toDisposable(() => this._providers.delete(key)));
+        store.add(toDisposable(() => {
+            this._providers.delete(key);
+            this._activeConnections.delete(key);
+            this._onDidChangeAvailability.fire();
+        }));
         this._providers.set(key, provider);
         this._providerStores.set(key, store);
         return provider;
@@ -340,7 +515,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             const remaining = deadline - Date.now();
             if (remaining <= 0) {
                 throw ( new Error(( localize(
-                    4389,
+                    5304,
                     "Timed out waiting for the Dev Container Agent Host to advertise agents."
                 ))));
             }
@@ -352,7 +527,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             ), token);
             if (timedOut) {
                 throw ( new Error(( localize(
-                    4389,
+                    5304,
                     "Timed out waiting for the Dev Container Agent Host to advertise agents."
                 ))));
             }
@@ -382,6 +557,129 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         active.provider.clearConnection();
         active.provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
     }
+    _stopContainer(key) {
+        return this._lifecycleOperations.queue(key, async () => {
+            const active = this._activeConnections.get(key);
+            if (!active || active.state === "stopped" || active.state === "removed") {
+                return true;
+            }
+            if (!active.connector.stopContainer) {
+                return false;
+            }
+            active.state = "stopping";
+            try {
+                const stopped = await active.connector.stopContainer(active.workspaceUri);
+                if (!stopped) {
+                    active.state = "running";
+                    return false;
+                }
+                await this._disconnectActiveTransport(active);
+                active.state = "stopped";
+                if (active.references === 0 && active.provider.getSessions().length === 0) {
+                    this._removeStoredConnection(key);
+                    this._removeProvider(key);
+                }
+                return stopped;
+            } catch (error) {
+                await this._connectActive(active);
+                throw error;
+            }
+        });
+    }
+    _removeContainer(key) {
+        return this._lifecycleOperations.queue(key, async () => {
+            const active = this._activeConnections.get(key);
+            if (!active || active.state === "removed") {
+                return true;
+            }
+            if (!active.connector.removeContainer) {
+                return false;
+            }
+            active.state = "removing";
+            try {
+                const removed = await active.connector.removeContainer(active.workspaceUri);
+                if (!removed) {
+                    active.state = "running";
+                    return false;
+                }
+                await this._disconnectActiveTransport(active);
+                active.state = "removed";
+                active.sandboxSupported = undefined;
+                this._knownSandboxSupport.delete(key);
+                active.provider.setDevContainerSandboxSupported(undefined);
+                this._onDidChangeAvailability.fire();
+                return removed;
+            } catch (error) {
+                await this._connectActive(active);
+                throw error;
+            }
+        });
+    }
+    _ensureActiveConnection(key, active, sandboxEnabled) {
+        return this._lifecycleOperations.queue(key, async () => {
+            if (this._isConnectedOrReconnecting(active.address)) {
+                active.state = "running";
+                return;
+            }
+            await this._connectActive(active, active.state === "removed" ? sandboxEnabled : undefined);
+        });
+    }
+    async _connectActive(active, sandboxEnabled) {
+        const previousState = active.state;
+        const requestedSandboxEnabled = sandboxEnabled ?? active.sandboxEnabled;
+        active.state = "connecting";
+        try {
+            const connected = await createDevContainerConnection(
+                active.connector,
+                active.workspaceUri,
+                active.address,
+                this._lifecycleTokenSource.token,
+                {
+                    resume: true,
+                    ...(requestedSandboxEnabled !== undefined ? {
+                        sandboxEnabled: requestedSandboxEnabled
+                    } : {})
+                }
+            );
+            this._setSandboxSupported(active.workspaceUri, connected.sandboxSupported);
+            const sourceEntry = getDevContainerSourceEntry(active.workspaceUri, this._remoteAgentHostService);
+            this._connectionFactory.stageConnection(
+                active.connector,
+                active.workspaceUri,
+                connected,
+                sourceEntry && resolveRemoteAgentHostEntryAuthority(sourceEntry),
+                requestedSandboxEnabled
+            );
+            this._remoteAgentHostService.reconnect(active.address, true);
+            const connectionInfo = await this._remoteAgentHostService.waitForConnection(active.address);
+            const connection = this._remoteAgentHostService.getConnection(connectionInfo.address);
+            if (!connection) {
+                throw ( new Error(( localize(
+                    5303,
+                    "Dev Container Agent Host connection was not available after connecting."
+                ))));
+            }
+            active.provider.setConnection(connection, connected.defaultDirectory ?? connectionInfo.defaultDirectory);
+            active.provider.setConnectionStatus(connectionInfo.status);
+            active.sandboxEnabled = requestedSandboxEnabled;
+            if (( this._storedConnections.has(getComparisonKey(active.workspaceUri))) || active.provider.getSessions().length > 0) {
+                this._storeConnection(active.workspaceUri, connected.name, requestedSandboxEnabled);
+            }
+            active.state = "running";
+            this._onDidChangeAvailability.fire();
+        } catch (error) {
+            this._connectionFactory.unstageConnection(active.address);
+            await this._remoteAgentHostService.removeRemoteAgentHost(active.address);
+            active.state = previousState;
+            throw error;
+        }
+    }
+    async _disconnectActiveTransport(active) {
+        this._connectionFactory.unstageConnection(active.address);
+        active.provider.clearConnection();
+        active.provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+        await this._remoteAgentHostService.removeRemoteAgentHost(active.address);
+    }
     _isConnectedOrReconnecting(address) {
         return ( this._remoteAgentHostService.connections.some(
             connection => connection.address === address && (RemoteAgentHostConnectionStatus.isConnected(connection.status) || RemoteAgentHostConnectionStatus.isReconnecting(connection.status))
@@ -391,6 +689,10 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         for (const [key, active] of this._activeConnections) {
             const connectionInfo = this._remoteAgentHostService.connections.find(connection => connection.address === active.address);
             if (!connectionInfo) {
+                if (active.state !== "running") {
+                    active.provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+                    continue;
+                }
                 this._activeConnections.delete(key);
                 this._connectionFactory.unstageConnection(active.address);
                 active.provider.clearConnection();
@@ -402,6 +704,10 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
             }
             active.provider.setConnectionStatus(connectionInfo.status);
             if (RemoteAgentHostConnectionStatus.isConnected(connectionInfo.status)) {
+                const sandboxSupported = this._connectionFactory.getSandboxSupported(active.address);
+                if (sandboxSupported !== active.sandboxSupported) {
+                    this._setSandboxSupported(active.workspaceUri, sandboxSupported);
+                }
                 const connection = this._remoteAgentHostService.getConnection(active.address);
                 if (connection) {
                     active.provider.setConnection(connection, connectionInfo.defaultDirectory);
@@ -441,12 +747,15 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
                     continue;
                 }
                 const uri = ( URI.parse(candidate.workspaceUri));
-                if (uri.scheme !== Schemas.file || candidate.name.length === 0) {
+                if ((uri.scheme !== Schemas.file && (uri.scheme !== AGENT_HOST_SCHEME || !uri.authority) && !findDevContainerSample(uri)) || candidate.name.length === 0) {
                     continue;
                 }
                 result.set(getComparisonKey(uri), {
                     workspaceUri: ( uri.toString()),
-                    name: candidate.name
+                    name: candidate.name,
+                    ...(candidate.sandboxEnabled !== undefined ? {
+                        sandboxEnabled: candidate.sandboxEnabled
+                    } : {})
                 });
             }
         } catch {
@@ -454,14 +763,18 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         }
         return result;
     }
-    _storeConnection(workspaceUri, name) {
+    _storeConnection(workspaceUri, name, sandboxEnabled) {
         const key = getComparisonKey(workspaceUri);
+        const existing = this._storedConnections.get(key);
+        const requestedSandboxEnabled = sandboxEnabled ?? this._activeConnections.get(key)?.sandboxEnabled ?? existing?.sandboxEnabled;
         const stored = {
             workspaceUri: ( workspaceUri.toString()),
-            name
+            name,
+            ...(requestedSandboxEnabled !== undefined ? {
+                sandboxEnabled: requestedSandboxEnabled
+            } : {})
         };
-        const existing = this._storedConnections.get(key);
-        if (existing?.workspaceUri === stored.workspaceUri && existing.name === stored.name) {
+        if (existing?.workspaceUri === stored.workspaceUri && existing.name === stored.name && existing.sandboxEnabled === stored.sandboxEnabled) {
             return;
         }
         this._storedConnections.set(key, stored);
@@ -483,6 +796,7 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         this._providerStores.deleteAndDispose(key);
     }
     dispose() {
+        this._lifecycleTokenSource.cancel();
         for (const pending of ( this._pendingConnections.values())) {
             pending.tokenSource.cancel();
             pending.tokenSource.dispose();
@@ -491,6 +805,6 @@ let DevContainerAgentHostService = class DevContainerAgentHostService extends Di
         super.dispose();
     }
 };
-DevContainerAgentHostService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IStorageService))], DevContainerAgentHostService));
+DevContainerAgentHostService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IStorageService)), ( __param(4, IWorkspaceTrustRequestService))], DevContainerAgentHostService));
 
 export { DevContainerAgentHostService };