@theia/dev-container 1.71.0-next.8 → 1.72.0-next.0

package/src/electron-node/remote-container-connection-provider.ts

@@ -17,7 +17,7 @@
 import * as net from 'net';
 import {
     ContainerConnectionOptions, ContainerConnectionResult,
-    DevContainerFile, RemoteContainerConnectionProvider
+    DevContainerFile, RemoteContainerConnectionProvider, RunningContainerInfo
 } from '../electron-common/remote-container-connection-provider';
 import { RemoteConnection, RemoteExecOptions, RemoteExecResult, RemoteExecTester, RemoteStatusReport } from '@theia/remote/lib/electron-node/remote-types';
 import { RemoteSetupResult, RemoteSetupService } from '@theia/remote/lib/electron-node/setup/remote-setup-service';
@@ -146,7 +146,7 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
 
             return {
                 containerId: container.id,
-                workspacePath: devContainerConfig.workspaceFolder ?? (await container.inspect()).Mounts[0].Destination,
+                workspacePath: devContainerConfig.workspaceFolder ?? this.inferWorkspacePath(await container.inspect()),
                 port: localPort.toString(),
             };
         } catch (e) {
@@ -182,6 +182,103 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
         return connection.container.inspect();
     }
 
+    async listRunningContainers(): Promise<RunningContainerInfo[]> {
+        try {
+            const docker = new Docker();
+            const containers = await docker.listContainers({ all: false });
+            return containers.map(container => ({
+                id: container.Id,
+                name: (container.Names[0] ?? '').replace(/^\//, ''),
+                image: container.Image,
+                status: container.Status
+            }));
+        } catch (e) {
+            console.error('Failed to list running containers:', e);
+            return [];
+        }
+    }
+
+    async attachToContainer(containerId: string): Promise<ContainerConnectionResult> {
+        const docker = new Docker();
+        const container = docker.getContainer(containerId);
+        const containerInfo = await container.inspect();
+
+        const progress = await this.messageService.showProgress({
+            text: 'Attaching to container',
+        });
+        try {
+            const report: RemoteStatusReport = message => progress.report({ message });
+            report('Connecting to remote system...');
+
+            const remote = new RemoteDockerContainerConnection({
+                id: generateUuid(),
+                name: containerInfo.Name.replace(/^\//, ''),
+                type: 'Dev Container',
+                docker,
+                container,
+                config: DevContainerConfiguration.empty(),
+                logger: this.logger
+            });
+
+            const result = await this.remoteSetup.setup({
+                connection: remote,
+                report,
+            });
+            remote.remoteSetupResult = result;
+
+            const registration = this.remoteConnectionService.register(remote);
+            const server = await this.serverProvider.getProxyServer(socket => {
+                remote.forwardOut(socket);
+            });
+            remote.onDidDisconnect(() => {
+                server.close();
+                registration.dispose();
+            });
+            const localPort = (server.address() as net.AddressInfo).port;
+            remote.localPort = localPort;
+
+            const workspacePath = this.inferWorkspacePath(containerInfo);
+
+            return {
+                containerId: container.id,
+                workspacePath,
+                port: localPort.toString(),
+            };
+        } catch (e) {
+            this.messageService.error(e.message);
+            console.error(e);
+            throw e;
+        } finally {
+            progress.cancel();
+        }
+    }
+
+    protected inferWorkspacePath(containerInfo: Docker.ContainerInspectInfo): string {
+        // Skip mounts that are injected by HostConfigSharingContribution
+        // (SSH dir, gitconfig) — these are not workspace mounts.
+        const workspaceMount = containerInfo.Mounts.find(m =>
+            !m.Destination.endsWith('/.ssh') &&
+            !m.Destination.endsWith('/.gitconfig') &&
+            m.Destination !== '/tmp/host_gitconfig'
+        );
+        return (workspaceMount?.Destination ?? containerInfo.Config.WorkingDir) || '/';
+    }
+
+    async removeContainer(containerId: string): Promise<void> {
+        try {
+            const docker = new Docker();
+            const container = docker.getContainer(containerId);
+            const info = await container.inspect();
+            if (info.State.Running) {
+                await container.stop();
+            }
+            await container.remove();
+        } catch (e) {
+            console.error('Failed to remove container:', e);
+            throw e;
+        }
+    }
+
     dispose(): void {
 
     }
@@ -251,12 +348,23 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
         this.logger = options.logger;
     }
 
+    protected getRemoteEnv(): string[] | undefined {
+        const remoteEnv = this.config.remoteEnv;
+        if (!remoteEnv || Object.keys(remoteEnv).length === 0) {
+            return undefined;
+        }
+        return Object.entries(remoteEnv)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `${key}=${value}`);
+    }
+
     async forwardOut(socket: Socket, port?: number): Promise<void> {
         const node = `${this.remoteSetupResult.nodeDirectory}/bin/node`;
         const devContainerServer = `${this.remoteSetupResult.applicationDirectory}/backend/dev-container-server.js`;
         try {
             const ttySession = await this.container.exec({
                 Cmd: ['sh', '-c', `${node} ${devContainerServer} -target-port=${port ?? this.remotePort}`],
+                Env: this.getRemoteEnv(),
                 AttachStdin: true, AttachStdout: true, AttachStderr: true
             });
 
@@ -274,7 +382,9 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
         const deferred = new Deferred<RemoteExecResult>();
         try {
             // TODO add windows container support
-            const execution = await this.container.exec({ Cmd: ['sh', '-c', `${cmd} ${args?.join(' ') ?? ''}`], AttachStdout: true, AttachStderr: true });
+            const execution = await this.container.exec({
+                Cmd: ['sh', '-c', `${cmd} ${args?.join(' ') ?? ''}`], Env: this.getRemoteEnv(), AttachStdout: true, AttachStderr: true
+            });
             let stdoutBuffer = '';
             let stderrBuffer = '';
             const stream = await execution?.start({});
@@ -298,7 +408,9 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
         const deferred = new Deferred<RemoteExecResult>();
         try {
             // TODO add windows container support
-            const execution = await this.container.exec({ Cmd: ['sh', '-c', `${cmd} ${args?.join(' ') ?? ''}`], AttachStdout: true, AttachStderr: true });
+            const execution = await this.container.exec({
+                Cmd: ['sh', '-c', `${cmd} ${args?.join(' ') ?? ''}`], Env: this.getRemoteEnv(), AttachStdout: true, AttachStderr: true
+            });
             let stdoutBuffer = '';
             let stderrBuffer = '';
             const stream = await execution?.start({});
@@ -386,11 +498,15 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
     protected async shutdownContainer(sync: boolean): Promise<unknown> {
         const remoteHost = this.getDockerHost();
 
-        const shutdownAction = this.config.shutdownAction ?? this.config.dockerComposeFile ? 'stopCompose' : 'stopContainer';
+        const shutdownAction = this.config.shutdownAction ?? (this.config.dockerComposeFile ? 'stopCompose' : 'stopContainer');
 
         if (shutdownAction === 'stopContainer') {
             return sync ? execSync(`docker ${remoteHost}stop ${this.container.id}`) : this.container.stop();
         } else if (shutdownAction === 'stopCompose') {
+            if (!this.config.dockerComposeFile) {
+                console.warn('shutdownAction is stopCompose but dockerComposeFile is not defined, falling back to stopContainer');
+                return sync ? execSync(`docker ${remoteHost}stop ${this.container.id}`) : this.container.stop();
+            }
             const composeFilePath = resolveComposeFilePath(this.config);
             return sync ? execSync(`docker ${remoteHost}compose -f ${composeFilePath} stop`) :
                 new Promise<void>((res, rej) => exec(`docker ${remoteHost}compose -f ${composeFilePath} stop`, err => {