@theia/dev-container 1.76.0-next.7 → 1.77.0-next.0

package/src/electron-browser/dev-container-startup-contribution.spec.ts

@@ -0,0 +1,245 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { LaunchArguments } from '@theia/core/lib/common/launch-arguments';
+
+const launchArgs = (values: Record<string, string[]>): LaunchArguments => ({ values, negated: [] });
+import { AttachContainerArgs, ContainerConnectionResult, RunningContainerInfo } from '../electron-common/remote-container-connection-provider';
+import { DevContainerStartupContribution } from './dev-container-startup-contribution';
+import type { AttachScreenErrorActions } from './dev-container-attach-screen';
+
+disableJSDOM();
+
+class TestDevContainerStartupContribution extends DevContainerStartupContribution {
+
+    forwardedArgs: LaunchArguments | undefined;
+    backendCalls = 0;
+    backendArgs: AttachContainerArgs | undefined;
+
+    resolve(): Promise<AttachContainerArgs | undefined> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (this as any).launchArgs = { getLaunchArgs: () => this.forwardedArgs };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (this as any).connectionProvider = {
+            getAttachContainerArgs: async () => {
+                this.backendCalls++;
+                return this.backendArgs;
+            }
+        };
+        return this.resolveAttachArgs();
+    }
+}
+
+describe('DevContainerStartupContribution#resolveAttachArgs', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    let contribution: TestDevContainerStartupContribution;
+
+    beforeEach(() => {
+        contribution = new TestDevContainerStartupContribution();
+    });
+
+    it('reads the container from the backend on a cold-start window (no forwarded options)', async () => {
+        contribution.forwardedArgs = undefined;
+        contribution.backendArgs = { containerId: 'A', scanForDevJson: true };
+
+        const result = await contribution.resolve();
+
+        expect(result).to.deep.equal({ containerId: 'A', scanForDevJson: true });
+        expect(contribution.backendCalls).to.equal(1);
+    });
+
+    it('reads the container from the forwarded options on a second-instance window', async () => {
+        contribution.forwardedArgs = launchArgs({ 'attach-container': ['B'] });
+        contribution.backendArgs = { containerId: 'A', scanForDevJson: true };
+
+        const result = await contribution.resolve();
+
+        expect(result).to.deep.equal({ containerId: 'B', scanForDevJson: true });
+        // The stale backend value (from the first launch) must not be consulted.
+        expect(contribution.backendCalls).to.equal(0);
+    });
+
+    it('honors --no-dev-json in the forwarded options', async () => {
+        contribution.forwardedArgs = { values: { 'attach-container': ['B'] }, negated: ['dev-json'] };
+
+        const result = await contribution.resolve();
+
+        expect(result).to.deep.equal({ containerId: 'B', scanForDevJson: false });
+    });
+
+    it('does not attach for a second-instance window without --attach-container', async () => {
+        contribution.forwardedArgs = launchArgs({ 'session-preference': ['foo=1'] });
+        contribution.backendArgs = { containerId: 'A', scanForDevJson: true };
+
+        const result = await contribution.resolve();
+
+        expect(result).to.be.undefined;
+        expect(contribution.backendCalls).to.equal(0);
+    });
+});
+
+class AttachHarness extends DevContainerStartupContribution {
+    stages: string[] = [];
+    errors: Array<{ message: string, actions: AttachScreenErrorActions }> = [];
+    disposeCount = 0;
+    showCount = 0;
+    openRemoteCalls: string[] = [];
+    protected statusListener: ((message: string) => void) | undefined;
+
+    setup(opts: { containers?: RunningContainerInfo[], attachResult?: ContainerConnectionResult | Error, statusDuringAttach?: string }): void {
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        (this as any).logger = { info: () => { }, warn: () => { }, error: () => { } };
+        (this as any).attachScreen = {
+            showAttaching: () => { this.showCount++; },
+            reportStage: (message: string) => this.stages.push(message),
+            reportError: (message: string, actions: AttachScreenErrorActions) => this.errors.push({ message, actions }),
+            dispose: () => { this.disposeCount++; }
+        };
+        (this as any).containerOutputProvider = {
+            onDidReportStatus: (cb: (message: string) => void) => {
+                this.statusListener = cb;
+                return { dispose: () => { this.statusListener = undefined; } };
+            }
+        };
+        (this as any).remotePreferences = {};
+        (this as any).remoteCliArgsCollector = { collect: async () => [] };
+        (this as any).connectionProvider = {
+            listRunningContainers: async () => opts.containers ?? [],
+            getWorkspaceCandidates: async () => [],
+            scanForDevContainerConfig: async () => undefined,
+            attachToContainer: async () => {
+                if (opts.statusDuringAttach) {
+                    this.statusListener?.(opts.statusDuringAttach);
+                }
+                if (opts.attachResult instanceof Error) {
+                    throw opts.attachResult;
+                }
+                return opts.attachResult!;
+            }
+        };
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+    }
+
+    protected override openRemote(port: string): void {
+        this.openRemoteCalls.push(port);
+    }
+
+    run(args: AttachContainerArgs): Promise<void> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (this as any).runStartupAttach(args);
+    }
+}
+
+describe('DevContainerStartupContribution#runStartupAttach', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    const runningB: RunningContainerInfo = { id: 'abc123def456', name: 'B', image: 'img', status: 'running', created: 0 };
+
+    it('reloads into the container on success without showing an error', async () => {
+        const harness = new AttachHarness();
+        harness.setup({ containers: [runningB], attachResult: { port: '9000', workspacePath: '/w', containerId: 'abc123def456' } });
+
+        await harness.run({ containerId: 'B', scanForDevJson: false });
+
+        expect(harness.openRemoteCalls).to.deep.equal(['9000']);
+        expect(harness.errors).to.have.lengthOf(0);
+        expect(harness.showCount).to.be.greaterThan(0);
+    });
+
+    it('forwards backend status messages to the attach screen', async () => {
+        const harness = new AttachHarness();
+        harness.setup({
+            containers: [runningB],
+            attachResult: { port: '9000', workspacePath: '/w', containerId: 'abc123def456' },
+            statusDuringAttach: 'Starting application on remote...'
+        });
+
+        await harness.run({ containerId: 'B', scanForDevJson: false });
+
+        expect(harness.stages).to.include('Starting application on remote...');
+    });
+
+    it('shows an error with retry/close when the container is not found, without reloading', async () => {
+        const harness = new AttachHarness();
+        harness.setup({ containers: [] });
+
+        await harness.run({ containerId: 'missing', scanForDevJson: false });
+
+        expect(harness.openRemoteCalls).to.have.lengthOf(0);
+        expect(harness.errors).to.have.lengthOf(1);
+        expect(harness.errors[0].message).to.match(/not found/i);
+    });
+
+    it('retry re-runs the attach; close dismisses the screen', async () => {
+        const harness = new AttachHarness();
+        harness.setup({ containers: [] });
+
+        await harness.run({ containerId: 'missing', scanForDevJson: false });
+        expect(harness.errors).to.have.lengthOf(1);
+
+        await harness.errors[0].actions.retry();
+        expect(harness.errors).to.have.lengthOf(2);
+
+        harness.errors[1].actions.close();
+        expect(harness.disposeCount).to.be.greaterThan(0);
+    });
+});
+
+class StartupHarness extends DevContainerStartupContribution {
+    errors: string[] = [];
+
+    setup(): void {
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        (this as any).logger = { info: () => { }, warn: () => { }, error: () => { } };
+        (this as any).launchArgs = { getLaunchArgs: () => undefined };
+        (this as any).attachScreen = { isAttached: false, dispose: () => { } };
+        (this as any).messageService = { error: (message: string) => this.errors.push(message) };
+        (this as any).connectionProvider = {
+            getAttachContainerArgs: async () => { throw new Error('backend unreachable'); }
+        };
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+    }
+
+    run(): Promise<void> {
+        return this.handleStartupAttach();
+    }
+}
+
+describe('DevContainerStartupContribution#handleStartupAttach', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    it('reports a failure to resolve the attach arguments on a cold start', async () => {
+        const harness = new StartupHarness();
+        harness.setup();
+
+        await harness.run();
+
+        expect(harness.errors).to.have.lengthOf(1);
+        expect(harness.errors[0]).to.contain('backend unreachable');
+    });
+});

package/src/electron-browser/dev-container-startup-contribution.ts

@@ -16,10 +16,15 @@
 
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { FrontendApplicationContribution } from '@theia/core/lib/browser';
-import { RemoteContainerConnectionProvider } from '../electron-common/remote-container-connection-provider';
+import { AttachContainerArgs, RemoteContainerConnectionProvider } from '../electron-common/remote-container-connection-provider';
 import { AbstractRemoteRegistryContribution } from '@theia/remote/lib/electron-browser/remote-registry-contribution';
 import { ILogger, MessageService, nls } from '@theia/core';
+import { LaunchArguments } from '@theia/core/lib/common/launch-arguments';
+import { WindowLaunchArgs } from '@theia/core/lib/browser/window/window-launch-args';
 import { RemotePreferences } from '@theia/remote/lib/electron-common/remote-preferences';
+import { ContainerOutputProvider } from './container-output-provider';
+import { DevContainerAttachScreen } from './dev-container-attach-screen';
+import { RemoteCliArgsCollector } from '@theia/remote/lib/electron-browser/remote-cli-args-collector';
 
 @injectable()
 export class DevContainerStartupContribution extends AbstractRemoteRegistryContribution implements FrontendApplicationContribution {
@@ -36,23 +41,71 @@ export class DevContainerStartupContribution extends AbstractRemoteRegistryContr
     @inject(RemotePreferences)
     protected readonly remotePreferences: RemotePreferences;
 
+    @inject(RemoteCliArgsCollector)
+    protected readonly remoteCliArgsCollector: RemoteCliArgsCollector;
+
+    @inject(ContainerOutputProvider)
+    protected readonly containerOutputProvider: ContainerOutputProvider;
+
+    @inject(DevContainerAttachScreen)
+    protected readonly attachScreen: DevContainerAttachScreen;
+
+    @inject(WindowLaunchArgs)
+    protected readonly launchArgs: WindowLaunchArgs;
+
     registerRemoteCommands(): void {
         // no commands to register — this contribution only handles startup
     }
 
     onStart(): void {
+        // For a CLI-driven attach the window is opened empty and reloads into the container once the
+        // attach completes. Show the "attaching" screen from the first paint so the user never
+        // interacts with the transient local window, before the (possibly RPC-bound) container id is
+        // even resolved.
+        if (this.isAttachPending()) {
+            this.attachScreen.showAttaching();
+        }
         this.handleStartupAttach();
     }
 
     protected async handleStartupAttach(): Promise<void> {
+        let args: AttachContainerArgs | undefined;
         try {
-            const args = await this.connectionProvider.getAttachContainerArgs();
-            if (!args) {
-                return;
+            args = await this.resolveAttachArgs();
+        } catch (e) {
+            // A rejection here (e.g. failing to redeem the launch args or reach the backend) must not
+            // escape as an unhandled rejection and leave the attach screen stuck on "Preparing to attach".
+            this.logger.error('CLI: Failed to resolve attach arguments during startup:', e);
+            const message = e instanceof Error ? e.message : String(e);
+            if (this.isAttachPending()) {
+                this.attachScreen.reportError(message, {
+                    retry: () => this.handleStartupAttach(),
+                    close: () => this.disposeAttachScreen()
+                });
+            } else {
+                // No attach screen is up, so fall back to a notification.
+                this.disposeAttachScreen();
+                this.messageService.error(nls.localize('theia/remote/dev-container/cliAttachError', 'Failed to attach to container: {0}', message));
             }
+            return;
+        }
+        if (!args) {
+            // Not attaching after all (e.g. a second-instance window without --attach-container):
+            // make sure a preliminary screen is not left up.
+            this.disposeAttachScreen();
+            return;
+        }
+        await this.runStartupAttach(args);
+    }
 
-            const { containerId, scanForDevJson } = args;
+    protected async runStartupAttach(args: AttachContainerArgs): Promise<void> {
+        const { containerId, scanForDevJson } = args;
+        this.attachScreen.showAttaching(containerId);
+        // Surface the backend's live status messages (RemoteStatusReport) on the attach screen.
+        const statusSubscription = this.containerOutputProvider.onDidReportStatus(message => this.attachScreen.reportStage(message));
+        try {
             this.logger.info(`CLI: --attach-container ${containerId}, initiating attach from frontend...`);
+            this.attachScreen.reportStage(nls.localize('theia/remote/dev-container/attachScreen/locating', 'Locating container {0}...', containerId));
 
             const containers = await this.connectionProvider.listRunningContainers();
             // Match by ID prefix (either direction — user may pass a short prefix or a full 64-char ID
@@ -64,13 +117,11 @@ export class DevContainerStartupContribution extends AbstractRemoteRegistryContr
             const target = matches[0];
 
             if (!target) {
-                const msg = nls.localize('theia/remote/dev-container/cliContainerNotFound',
-                    'Container "{0}" not found or not running.', containerId);
-                this.logger.error(`CLI: ${msg}`);
-                this.messageService.error(msg);
-                return;
+                throw new Error(nls.localize('theia/remote/dev-container/cliContainerNotFound',
+                    'Container "{0}" not found or not running.', containerId));
             }
 
+            this.attachScreen.reportStage(nls.localize('theia/remote/dev-container/attachScreen/preparingWorkspace', 'Preparing workspace...'));
             const candidates = await this.connectionProvider.getWorkspaceCandidates(target.id);
             const workspacePath = candidates.length > 0 ? candidates[0].path : '/';
 
@@ -78,22 +129,69 @@ export class DevContainerStartupContribution extends AbstractRemoteRegistryContr
                 ? await this.connectionProvider.scanForDevContainerConfig(target.id, workspacePath)
                 : undefined;
 
+            this.attachScreen.reportStage(nls.localize('theia/remote/dev-container/attachScreen/starting', 'Starting the application inside the container...'));
             const result = await this.connectionProvider.attachToContainer({
                 containerId: target.id,
                 workspacePath,
                 devcontainerFile,
                 nodeDownloadTemplate: this.remotePreferences['remote.nodeDownloadTemplate'],
+                additionalArgs: await this.remoteCliArgsCollector.collect(),
             });
 
             this.logger.info(`CLI: startup attach ready, proxy on port ${result.port}, workspace: ${result.workspacePath}`);
+            // Reloads the window into the container; the attach screen is torn down by the navigation.
             this.openRemote(result.port, false, result.workspacePath);
         } catch (e) {
             this.logger.error('CLI: Failed to attach to container during startup:', e);
-            this.messageService.error(nls.localize(
-                'theia/remote/dev-container/cliAttachError',
-                'Failed to attach to container: {0}',
-                e instanceof Error ? e.message : String(e)
-            ));
+            const message = e instanceof Error ? e.message : String(e);
+            this.attachScreen.reportError(message, {
+                retry: () => this.runStartupAttach(args),
+                close: () => this.attachScreen.dispose()
+            });
+        } finally {
+            statusSubscription.dispose();
         }
     }
+
+    /**
+     * Whether this window was opened for a CLI-driven attach. Decided from the window's own launch
+     * options, which are available synchronously from the first paint, rather than from a flag in
+     * the URL: only `@theia/dev-container` knows what `--attach-container` means.
+     */
+    protected isAttachPending(): boolean {
+        const args = this.launchArgs.getLaunchArgs();
+        return args !== undefined && LaunchArguments.lastValue(args, 'attach-container') !== undefined;
+    }
+
+    /**
+     * Disposes the attach screen, but only when it is actually on screen. The screen is a singleton,
+     * so disposing it on the many windows that never attach would leave a disposed widget behind
+     * that a later {@link DevContainerAttachScreen.showAttaching} could no longer attach.
+     */
+    protected disposeAttachScreen(): void {
+        if (this.attachScreen.isAttached) {
+            this.attachScreen.dispose();
+        }
+    }
+
+    /**
+     * Resolves the container to attach to on startup.
+     *
+     * A forwarded (second-instance) launch carries its CLI options, provided by the trusted main
+     * process. For such windows those options are the only source, because the shared backend still
+     * reflects the original cold-start launch and cannot distinguish between windows. A cold-start
+     * window has no forwarded options and reads them from the backend instead.
+     */
+    protected async resolveAttachArgs(): Promise<AttachContainerArgs | undefined> {
+        const forwarded = this.launchArgs.getLaunchArgs();
+        if (forwarded !== undefined) {
+            const containerId = LaunchArguments.lastValue(forwarded, 'attach-container');
+            if (!containerId) {
+                return undefined;
+            }
+            return { containerId, scanForDevJson: !LaunchArguments.isNegated(forwarded, 'dev-json') };
+        }
+        return this.connectionProvider.getAttachContainerArgs();
+    }
+
 }

package/src/electron-browser/style/dev-container-attach-screen.css

@@ -0,0 +1,75 @@
+/********************************************************************************
+ * Copyright (C) 2026 EclipseSource GmbH and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+.theia-dev-container-attach-screen {
+    position: fixed;
+    inset: 0;
+    z-index: 10000;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--theia-editor-background);
+    color: var(--theia-foreground);
+    font-family: var(--theia-ui-font-family);
+    font-size: var(--theia-ui-font-size1);
+}
+
+.theia-dev-container-attach-screen-content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    text-align: center;
+    max-width: 480px;
+    padding: calc(var(--theia-ui-padding) * 4);
+}
+
+.theia-dev-container-attach-screen-logo {
+    max-width: 240px;
+    max-height: 96px;
+    margin-bottom: calc(var(--theia-ui-padding) * 4);
+}
+
+.theia-dev-container-attach-screen-spinner {
+    font-size: calc(var(--theia-ui-font-size1) * 2.5);
+    color: var(--theia-icon-foreground);
+    margin-bottom: calc(var(--theia-ui-padding) * 3);
+}
+
+.theia-dev-container-attach-screen-title {
+    font-size: var(--theia-ui-font-size3);
+    font-weight: 600;
+    margin: 0 0 var(--theia-ui-padding) 0;
+}
+
+.theia-dev-container-attach-screen-stage {
+    margin-bottom: calc(var(--theia-ui-padding) * 2);
+}
+
+.theia-dev-container-attach-screen-note {
+    color: var(--theia-descriptionForeground);
+    font-size: var(--theia-ui-font-size0);
+}
+
+.theia-dev-container-attach-screen-alert {
+    margin-bottom: calc(var(--theia-ui-padding) * 3);
+    text-align: left;
+}
+
+.theia-dev-container-attach-screen-actions {
+    display: flex;
+    justify-content: center;
+    gap: calc(var(--theia-ui-padding) * 2);
+}

package/src/electron-common/container-output-provider.ts

@@ -16,4 +16,10 @@
 
 export interface ContainerOutputProvider {
     onRemoteOutput(output: string): void;
+    /**
+     * Receives curated status messages (from {@link RemoteStatusReport}) describing the current
+     * attach phase, e.g. "Starting application on remote...". Used to drive the "attaching" screen.
+     * Optional so that existing implementers of this interface keep compiling.
+     */
+    onRemoteStatus?(message: string): void;
 }

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

@@ -27,6 +27,11 @@ export interface ContainerConnectionOptions {
     lastContainerInfo?: LastContainerInfo
     devcontainerFile: string;
     workspacePath?: string;
+    /**
+     * Additional CLI arguments to pass to the container's remote backend, e.g. the
+     * `--session-preference` values forwarded to a second-instance window.
+     */
+    additionalArgs?: string[];
 }
 
 export interface LastContainerInfo {
@@ -64,6 +69,11 @@ export interface AttachContainerOptions {
     workspacePath: string;
     nodeDownloadTemplate?: string;
     devcontainerFile?: string;
+    /**
+     * Additional CLI arguments to pass to the container's remote backend, e.g. the
+     * `--session-preference` values forwarded to a second-instance window.
+     */
+    additionalArgs?: string[];
 }
 
 export interface AttachContainerArgs {

package/src/electron-main/dev-container-claim-contribution.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { ElectronMainApplicationContribution } from '@theia/core/lib/electron-main/electron-main-application';
+import { LaunchArguments } from '@theia/core/lib/common/launch-arguments';
+
+/**
+ * Claims windows opened for a CLI `--attach-container` launch. Such a window is opened empty and
+ * reloads into the container once the attach completes; claiming it lets core open an empty window
+ * (instead of restoring the last workspace) and flag it so the dev-container frontend can show its
+ * "attaching" screen from the first paint. Keeps the knowledge of `--attach-container` in
+ * `@theia/dev-container` rather than in core.
+ */
+@injectable()
+export class DevContainerClaimContribution implements ElectronMainApplicationContribution {
+
+    claimsWindow(args: LaunchArguments): boolean {
+        return LaunchArguments.lastValue(args, 'attach-container') !== undefined;
+    }
+}

package/src/electron-main/dev-container-electron-main-module.ts

@@ -0,0 +1,24 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { ElectronMainApplicationContribution } from '@theia/core/lib/electron-main/electron-main-application';
+import { DevContainerClaimContribution } from './dev-container-claim-contribution';
+
+export default new ContainerModule(bind => {
+    bind(DevContainerClaimContribution).toSelf().inSingletonScope();
+    bind(ElectronMainApplicationContribution).toService(DevContainerClaimContribution);
+});

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

@@ -255,7 +255,7 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
 
                 report('Connecting to remote system...');
 
-                const result = await this.setupRemoteConnection(container, docker, devContainerConfig, options.nodeDownloadTemplate, report);
+                const result = await this.setupRemoteConnection(container, docker, devContainerConfig, options.nodeDownloadTemplate, report, options.additionalArgs);
                 remote = result.remote;
 
                 await this.containerService.postConnect(options.devcontainerFile, remote, this.outputProvider, context);
@@ -296,7 +296,11 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
     async attachToContainer(options: AttachContainerOptions): Promise<ContainerConnectionResult> {
         const progress = await this.messageService.showProgress({ text: 'Attaching to container' });
         try {
-            const report: RemoteStatusReport = message => progress.report({ message });
+            const report: RemoteStatusReport = message => {
+                progress.report({ message });
+                // Mirror the status to the frontend so the CLI "attaching" screen can show live progress.
+                this.outputProvider?.onRemoteStatus?.(message);
+            };
             const docker = await this.createDockerConnection();
             const container = docker.getContainer(options.containerId);
 
@@ -318,7 +322,7 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
             try {
                 report('Connecting to remote system...');
 
-                const result = await this.setupRemoteConnection(container, docker, config, options.nodeDownloadTemplate, report);
+                const result = await this.setupRemoteConnection(container, docker, config, options.nodeDownloadTemplate, report, options.additionalArgs);
                 remote = result.remote;
 
                 if (options.devcontainerFile) {
@@ -378,7 +382,7 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
      */
     protected async setupRemoteConnection(
         container: Docker.Container, docker: Docker, config: DevContainerConfiguration,
-        nodeDownloadTemplate: string | undefined, report: RemoteStatusReport
+        nodeDownloadTemplate: string | undefined, report: RemoteStatusReport, additionalArgs?: string[]
     ): Promise<{ localPort: number; remote: RemoteDockerContainerConnection }> {
         const remote = new RemoteDockerContainerConnection({
             id: generateUuid(),
@@ -395,7 +399,8 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
             result = await this.remoteSetup.setup({
                 connection: remote,
                 report,
-                nodeDownloadTemplate
+                nodeDownloadTemplate,
+                additionalArgs
             });
         } catch (e) {
             remote.dispose();