@theia/dev-container 1.72.0-next.59 → 1.72.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@theia/dev-container",
-  "version": "1.72.0-next.59+044f7bfc5",
+  "version": "1.72.1",
   "description": "Theia - Editor Preview Extension",
   "dependencies": {
-    "@theia/core": "1.72.0-next.59+044f7bfc5",
-    "@theia/output": "1.72.0-next.59+044f7bfc5",
-    "@theia/remote": "1.72.0-next.59+044f7bfc5",
-    "@theia/workspace": "1.72.0-next.59+044f7bfc5",
+    "@theia/core": "1.72.1",
+    "@theia/output": "1.72.1",
+    "@theia/remote": "1.72.1",
+    "@theia/workspace": "1.72.1",
     "dockerode": "^4.0.12",
     "jsonc-parser": "^3.3.1",
     "uuid": "^8.3.2"
@@ -45,11 +45,11 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.71.0",
+    "@theia/ext-scripts": "1.72.1",
     "@types/dockerode": "^3.3.47"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "044f7bfc503932372f324434beabbf5422dc583f"
+  "gitHead": "037c4b3e52055fc9962c9761564f431fc4864eb4"
 }

package/src/electron-browser/container-connection-contribution.ts

@@ -16,15 +16,20 @@
 
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { AbstractRemoteRegistryContribution, RemoteRegistry } from '@theia/remote/lib/electron-browser/remote-registry-contribution';
-import { DevContainerFile, LastContainerInfo, RemoteContainerConnectionProvider } from '../electron-common/remote-container-connection-provider';
+import {
+    DevContainerFile, LastContainerInfo, RemoteContainerConnectionProvider,
+    RunningContainerInfo, WorkspaceCandidate
+} from '../electron-common/remote-container-connection-provider';
 import { WorkspaceStorageService } from '@theia/workspace/lib/browser/workspace-storage-service';
-import { Command, MaybePromise, MessageService, nls, QuickInputService, URI } from '@theia/core';
+import { Command, ILogger, MaybePromise, MessageService, nls, QuickInputService, URI } from '@theia/core';
 import { WorkspaceInput, WorkspaceOpenHandlerContribution, WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import { ContainerOutputProvider } from './container-output-provider';
 import { WorkspaceServer } from '@theia/workspace/lib/common';
 import { DEV_CONTAINER_PATH_QUERY, DEV_CONTAINER_WORKSPACE_SCHEME } from '../electron-common/dev-container-workspaces';
 import { RemotePreferences } from '@theia/remote/lib/electron-common/remote-preferences';
 import { LocalStorageService } from '@theia/core/lib/browser';
+import { ConfirmDialog, Dialog } from '@theia/core/lib/browser/dialogs';
+import { DevContainerPreferences } from '../electron-common/dev-container-preferences';
 
 export namespace RemoteContainerCommands {
     export const REOPEN_IN_CONTAINER = Command.toLocalizedCommand({
@@ -32,7 +37,6 @@ export namespace RemoteContainerCommands {
         label: 'Reopen in Container',
         category: 'Dev Container'
     }, 'theia/remote/dev-container/connect');
-
     export const ATTACH_TO_CONTAINER = Command.toLocalizedCommand({
         id: 'dev-container:attach-to-container',
         label: 'Attach to Running Container',
@@ -85,6 +89,12 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
     @inject(ContainerOutputProvider)
     protected readonly containerOutputProvider: ContainerOutputProvider;
 
+    @inject(DevContainerPreferences)
+    protected readonly devContainerPreferences: DevContainerPreferences;
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
     protected hasDevContainerFiles = false;
 
     @postConstruct()
@@ -123,13 +133,13 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
             execute: () => this.openInContainer(),
             isVisible: () => !this.isRemoteSession() && this.hasDevContainerFiles
         });
-        registry.registerCommand(RemoteContainerCommands.ATTACH_TO_CONTAINER, {
-            execute: () => this.attachToContainer()
-        });
         registry.registerCommand(RemoteContainerCommands.REBUILD_CONTAINER, {
             execute: () => this.rebuildContainer(),
             isVisible: () => this.isRemoteSession()
         });
+        registry.registerCommand(RemoteContainerCommands.ATTACH_TO_CONTAINER, {
+            execute: () => this.attachToRunningContainer()
+        });
     }
 
     protected isRemoteSession(): boolean {
@@ -187,33 +197,6 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
         this.doOpenInContainer(devcontainerFile);
     }
 
-    async attachToContainer(): Promise<void> {
-        const containers = await this.connectionProvider.listRunningContainers();
-        if (containers.length === 0) {
-            this.messageService.info(nls.localize('theia/remote/dev-container/noRunningContainers', 'No running containers found.'));
-            return;
-        }
-
-        const selected = await this.quickInputService.pick(containers.map(container => ({
-            type: 'item' as const,
-            label: container.name || container.id.substring(0, 12),
-            description: container.image,
-            detail: container.status,
-            container
-        })), {
-            title: nls.localize('theia/remote/dev-container/selectContainer', 'Select a running container to attach to')
-        });
-
-        if (!selected) {
-            return;
-        }
-
-        this.containerOutputProvider.openChannel();
-
-        const connectionResult = await this.connectionProvider.attachToContainer(selected.container.id);
-        this.openRemote(connectionResult.port, false, connectionResult.workspacePath);
-    }
-
     async rebuildContainer(): Promise<void> {
         this.containerOutputProvider.openChannel();
         const progress = await this.messageService.showProgress({
@@ -230,7 +213,7 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
                 try {
                     await this.connectionProvider.removeContainer(ctx.containerId);
                 } catch (error) {
-                    // Container may already be gone, ignore error
+                    this.logger.debug('Container removal failed (may already be gone):', error);
                 }
                 const lastContainerKey = `${LAST_USED_CONTAINER}:${ctx.devcontainerFilePath}`;
                 await this.storageService.setData(lastContainerKey, undefined);
@@ -254,7 +237,7 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
                 try {
                     await this.connectionProvider.removeContainer(lastContainerInfo.id);
                 } catch (error) {
-                    // Container may already be gone, ignore error
+                    this.logger.debug('Container removal failed (may already be gone):', error);
                 }
                 await this.storageService.setData(lastContainerInfoKey, undefined);
             }
@@ -281,25 +264,159 @@ export class ContainerConnectionContribution extends AbstractRemoteRegistryContr
             workspacePath: hostWorkspacePath
         });
 
-        this.storageService.setData<LastContainerInfo>(lastContainerInfoKey, {
+        await this.storageService.setData<LastContainerInfo>(lastContainerInfoKey, {
             id: connectionResult.containerId,
             lastUsed: Date.now()
         });
 
         // Store full context so rebuild works from inside the container
-        this.storageService.setData<DevContainerContext>(ACTIVE_DEV_CONTAINER_CONTEXT, {
+        await this.storageService.setData<DevContainerContext>(ACTIVE_DEV_CONTAINER_CONTEXT, {
             devcontainerFilePath: devcontainerFile.path,
             devcontainerFileName: devcontainerFile.name,
             hostWorkspacePath: hostWorkspacePath ?? '',
             containerId: connectionResult.containerId,
         });
 
-        this.workspaceServer.setMostRecentlyUsedWorkspace(
+        await this.workspaceServer.setMostRecentlyUsedWorkspace(
             `${DEV_CONTAINER_WORKSPACE_SCHEME}:${hostWorkspacePath}?${DEV_CONTAINER_PATH_QUERY}=${devcontainerFile.path}`);
 
         this.openRemote(connectionResult.port, false, connectionResult.workspacePath);
     }
 
+    async attachToRunningContainer(): Promise<void> {
+        try {
+            const confirmed = await new ConfirmDialog({
+                title: nls.localize('theia/remote/dev-container/attachWarningTitle', 'Attach to Container'),
+                msg: nls.localize('theia/remote/dev-container/attachWarning',
+                    'Attaching to a container will execute code inside it. Only attach to containers whose origin you trust.'),
+                ok: nls.localizeByDefault('Continue'),
+                cancel: Dialog.CANCEL,
+            }).open();
+            if (!confirmed) {
+                return;
+            }
+
+            const containers = await this.connectionProvider.listRunningContainers();
+            if (containers.length === 0) {
+                this.messageService.info(
+                    nls.localize('theia/remote/dev-container/noRunningContainers', 'No running containers found.')
+                );
+                return;
+            }
+
+            const selectedItem = await this.quickInputService.pick(containers.map(container => ({
+                type: 'item' as const,
+                label: container.name,
+                description: container.image,
+                detail: container.status,
+                container
+            })), {
+                title: nls.localize('theia/remote/dev-container/selectContainer', 'Select a running container to attach to')
+            });
+
+            if (!selectedItem) {
+                return;
+            }
+
+            const selectedContainer: RunningContainerInfo = selectedItem.container;
+
+            const candidates: WorkspaceCandidate[] = await this.connectionProvider.getWorkspaceCandidates(selectedContainer.id);
+
+            const customPathId = '__custom_path__';
+            const pathItem = await this.quickInputService.pick([
+                ...candidates.map(candidate => ({
+                    type: 'item' as const,
+                    label: candidate.path,
+                    description: candidate.source
+                })),
+                {
+                    type: 'item' as const,
+                    id: customPathId,
+                    label: nls.localize('theia/remote/dev-container/enterCustomPath', 'Enter custom path...'),
+                    description: ''
+                }
+            ], {
+                title: nls.localize('theia/remote/dev-container/selectWorkspacePath', 'Select a workspace path inside the container')
+            });
+
+            if (!pathItem) {
+                return;
+            }
+
+            let selectedPath: string | undefined;
+            if ('id' in pathItem && pathItem.id === customPathId) {
+                selectedPath = await this.quickInputService.input({
+                    prompt: nls.localize('theia/remote/dev-container/enterWorkspacePath', 'Enter the workspace path inside the container'),
+                    value: '/'
+                });
+            } else {
+                selectedPath = pathItem.label;
+            }
+
+            if (!selectedPath) {
+                return;
+            }
+
+            let devcontainerFile: string | undefined;
+            const applyConfigPref = this.devContainerPreferences['devcontainer.attach.applyFoundConfig'];
+
+            if (applyConfigPref !== 'never') {
+                const foundConfig = await this.connectionProvider.scanForDevContainerConfig(selectedContainer.id, selectedPath);
+                if (foundConfig) {
+                    if (applyConfigPref === 'always') {
+                        devcontainerFile = foundConfig;
+                    } else {
+                        // 'ask'
+                        const applyConfig = await new ConfirmDialog({
+                            title: nls.localize('theia/remote/dev-container/foundConfigTitle', 'Dev Container Configuration Found'),
+                            msg: nls.localize('theia/remote/dev-container/foundConfigMsg',
+                                'A devcontainer.json was found at {0}. Would you like to apply its post-attach settings (extensions, port forwarding, etc.)?',
+                                foundConfig),
+                            ok: nls.localizeByDefault('Apply'),
+                            cancel: Dialog.CANCEL,
+                        }).open();
+                        if (applyConfig) {
+                            devcontainerFile = foundConfig;
+                        }
+                    }
+                }
+            }
+
+            this.containerOutputProvider.openChannel();
+
+            const progress = await this.messageService.showProgress({
+                text: nls.localize('theia/remote/dev-container/attaching', 'Attaching to container')
+            });
+
+            try {
+                const connectionResult = await this.connectionProvider.attachToContainer({
+                    containerId: selectedContainer.id,
+                    workspacePath: selectedPath,
+                    nodeDownloadTemplate: this.remotePreferences['remote.nodeDownloadTemplate'],
+                    devcontainerFile,
+                });
+
+                // Store context so rebuild works from inside the container
+                await this.storageService.setData<DevContainerContext>(ACTIVE_DEV_CONTAINER_CONTEXT, {
+                    devcontainerFilePath: devcontainerFile ?? '',
+                    devcontainerFileName: devcontainerFile ? URI.fromFilePath(devcontainerFile).path.base : '',
+                    hostWorkspacePath: '',
+                    containerId: connectionResult.containerId,
+                });
+
+                this.openRemote(connectionResult.port, false, connectionResult.workspacePath);
+            } finally {
+                progress.cancel();
+            }
+        } catch (e) {
+            this.messageService.error(nls.localize(
+                'theia/remote/dev-container/attachError',
+                'Failed to attach to container: {0}',
+                e instanceof Error ? e.message : String(e)
+            ));
+        }
+    }
+
     async getOrSelectDevcontainerFile(): Promise<DevContainerFile | undefined> {
         const workspace = this.workspaceService.workspace;
         if (!workspace) {

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

@@ -31,6 +31,8 @@ export class ContainerOutputProvider implements ContainerOutputProvider {
     };
 
     onRemoteOutput(output: string): void {
-        this.currentChannel?.appendLine(output);
+        if (output) {
+            this.currentChannel?.appendLine(output);
+        }
     }
 }

package/src/electron-browser/dev-container-frontend-module.ts

@@ -24,6 +24,8 @@ import { FrontendApplicationContribution, LabelProviderContribution } from '@the
 import { WorkspaceOpenHandlerContribution } from '@theia/workspace/lib/browser/workspace-service';
 import { WindowTitleContribution } from '@theia/core/lib/browser/window/window-title-service';
 import { DevContainerSuggestionContribution } from './dev-container-suggestion-contribution';
+import { bindDevContainerPreferences } from '../electron-common/dev-container-preferences';
+import { DevContainerStartupContribution } from './dev-container-startup-contribution';
 
 export default new ContainerModule(bind => {
     bind(ContainerConnectionContribution).toSelf().inSingletonScope();
@@ -31,6 +33,7 @@ export default new ContainerModule(bind => {
     bind(WorkspaceOpenHandlerContribution).toService(ContainerConnectionContribution);
 
     bind(ContainerOutputProvider).toSelf().inSingletonScope();
+    bindDevContainerPreferences(bind);
 
     bind(RemoteContainerConnectionProvider).toDynamicValue(ctx => {
         const outputProvider = ctx.container.get(ContainerOutputProvider);
@@ -44,4 +47,7 @@ export default new ContainerModule(bind => {
 
     bind(DevContainerSuggestionContribution).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(DevContainerSuggestionContribution);
+
+    bind(DevContainerStartupContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(DevContainerStartupContribution);
 });

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

@@ -0,0 +1,99 @@
+// *****************************************************************************
+// 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { 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 { RemotePreferences } from '@theia/remote/lib/electron-common/remote-preferences';
+
+@injectable()
+export class DevContainerStartupContribution extends AbstractRemoteRegistryContribution implements FrontendApplicationContribution {
+
+    @inject(RemoteContainerConnectionProvider)
+    protected readonly connectionProvider: RemoteContainerConnectionProvider;
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
+
+    @inject(RemotePreferences)
+    protected readonly remotePreferences: RemotePreferences;
+
+    registerRemoteCommands(): void {
+        // no commands to register — this contribution only handles startup
+    }
+
+    onStart(): void {
+        this.handleStartupAttach();
+    }
+
+    protected async handleStartupAttach(): Promise<void> {
+        try {
+            const args = await this.connectionProvider.getAttachContainerArgs();
+            if (!args) {
+                return;
+            }
+
+            const { containerId, scanForDevJson } = args;
+            this.logger.info(`CLI: --attach-container ${containerId}, initiating attach from frontend...`);
+
+            const containers = await this.connectionProvider.listRunningContainers();
+            // Match by ID prefix (either direction — user may pass a short prefix or a full 64-char ID
+            // while listRunningContainers returns 12-char truncated IDs) or exact name.
+            const matches = containers.filter(c => c.id.startsWith(containerId) || containerId.startsWith(c.id) || c.name === containerId);
+            if (matches.length > 1) {
+                this.logger.warn(`CLI: container identifier "${containerId}" matches ${matches.length} containers, using first match: ${matches[0].name || matches[0].id}`);
+            }
+            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;
+            }
+
+            const candidates = await this.connectionProvider.getWorkspaceCandidates(target.id);
+            const workspacePath = candidates.length > 0 ? candidates[0].path : '/';
+
+            const devcontainerFile = scanForDevJson
+                ? await this.connectionProvider.scanForDevContainerConfig(target.id, workspacePath)
+                : undefined;
+
+            const result = await this.connectionProvider.attachToContainer({
+                containerId: target.id,
+                workspacePath,
+                devcontainerFile,
+                nodeDownloadTemplate: this.remotePreferences['remote.nodeDownloadTemplate'],
+            });
+
+            this.logger.info(`CLI: startup attach ready, proxy on port ${result.port}, workspace: ${result.workspacePath}`);
+            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)
+            ));
+        }
+    }
+}

package/src/electron-common/dev-container-preferences.ts

@@ -0,0 +1,53 @@
+// *****************************************************************************
+// 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 { interfaces } from '@theia/core/shared/inversify';
+import { PreferenceProxy } from '@theia/core/lib/common/preferences/preference-proxy';
+import { nls } from '@theia/core/lib/common/nls';
+import { PreferenceProxyFactory } from '@theia/core/lib/common/preferences/injectable-preference-proxy';
+import { PreferenceContribution, PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
+
+export const DevContainerPreferenceSchema: PreferenceSchema = {
+    properties: {
+        'devcontainer.attach.applyFoundConfig': {
+            type: 'string',
+            enum: ['always', 'ask', 'never'],
+            default: 'ask',
+            markdownDescription: nls.localize(
+                'theia/devContainer/attach/applyFoundConfig',
+                'Controls whether to apply a devcontainer.json found inside a container when attaching. '
+                + 'Extensions, settings, port forwarding, and post-attach commands from the configuration will be applied.'
+            )
+        }
+    }
+};
+
+export interface DevContainerPreferenceConfiguration {
+    'devcontainer.attach.applyFoundConfig': 'always' | 'ask' | 'never';
+}
+
+export const DevContainerPreferenceContribution = Symbol('DevContainerPreferenceContribution');
+export const DevContainerPreferences = Symbol('DevContainerPreferences');
+export type DevContainerPreferences = PreferenceProxy<DevContainerPreferenceConfiguration>;
+
+export function bindDevContainerPreferences(bind: interfaces.Bind): void {
+    bind(DevContainerPreferences).toDynamicValue(ctx => {
+        const factory = ctx.container.get<PreferenceProxyFactory>(PreferenceProxyFactory);
+        return factory(DevContainerPreferenceSchema);
+    }).inSingletonScope();
+    bind(DevContainerPreferenceContribution).toConstantValue({ schema: DevContainerPreferenceSchema });
+    bind(PreferenceContribution).toService(DevContainerPreferenceContribution);
+}

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

@@ -50,6 +50,25 @@ export interface RunningContainerInfo {
     name: string;
     image: string;
     status: string;
+    created: number;
+}
+
+export interface WorkspaceCandidate {
+    path: string;
+    /** Describes where this candidate came from */
+    source: 'working-dir' | 'bind-mount' | 'devcontainer-label' | 'fallback';
+}
+
+export interface AttachContainerOptions {
+    containerId: string;
+    workspacePath: string;
+    nodeDownloadTemplate?: string;
+    devcontainerFile?: string;
+}
+
+export interface AttachContainerArgs {
+    containerId: string;
+    scanForDevJson: boolean;
 }
 
 export interface RemoteContainerConnectionProvider extends RpcServer<ContainerOutputProvider> {
@@ -57,6 +76,9 @@ export interface RemoteContainerConnectionProvider extends RpcServer<ContainerOu
     getDevContainerFiles(workspacePath: string): Promise<DevContainerFile[]>;
     getCurrentContainerInfo(port: number): Promise<ContainerInspectInfo | undefined>;
     listRunningContainers(): Promise<RunningContainerInfo[]>;
-    attachToContainer(containerId: string): Promise<ContainerConnectionResult>;
+    getWorkspaceCandidates(containerId: string): Promise<WorkspaceCandidate[]>;
+    scanForDevContainerConfig(containerId: string, workspacePath: string): Promise<string | undefined>;
+    getAttachContainerArgs(): Promise<AttachContainerArgs | undefined>;
+    attachToContainer(options: AttachContainerOptions): Promise<ContainerConnectionResult>;
     removeContainer(containerId: string): Promise<void>;
 }

package/src/electron-node/dev-container-backend-module.ts

@@ -16,6 +16,8 @@
 
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+import { DevContainerCliContribution } from './dev-container-cli-contribution';
+import { CliContribution } from '@theia/core/lib/node';
 import { DevContainerConnectionProvider } from './remote-container-connection-provider';
 import { RemoteContainerConnectionProvider, RemoteContainerConnectionProviderPath } from '../electron-common/remote-container-connection-provider';
 import { ContainerCreationContribution, DockerContainerService } from './docker-container-service';
@@ -66,4 +68,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(DevContainerWorkspaceHandler).toSelf().inSingletonScope();
     bind(WorkspaceHandlerContribution).toService(DevContainerWorkspaceHandler);
+
+    bind(DevContainerCliContribution).toSelf().inSingletonScope();
+    bind(CliContribution).toService(DevContainerCliContribution);
 });

package/src/electron-node/dev-container-cli-contribution.spec.ts

@@ -0,0 +1,106 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { DevContainerCliContribution } from './dev-container-cli-contribution';
+import { Arguments } from '@theia/core/shared/yargs';
+
+function createArgs(overrides: Record<string, unknown> = {}): Arguments {
+    return {
+        _: [],
+        '$0': '',
+        ...overrides
+    } as unknown as Arguments;
+}
+
+describe('DevContainerCliContribution', () => {
+
+    describe('setArguments / getAttachContainerId', () => {
+
+        it('should return undefined when --attach-container not provided', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs());
+            expect(contribution.getAttachContainerId()).to.be.undefined;
+        });
+
+        it('should stash container ID from --attach-container', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'attach-container': 'abc123' }));
+            expect(contribution.getAttachContainerId()).to.equal('abc123');
+        });
+
+        it('should convert numeric container ID to string', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'attach-container': 12345 }));
+            expect(contribution.getAttachContainerId()).to.equal('12345');
+        });
+
+        it('should ignore empty string --attach-container', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'attach-container': '' }));
+            expect(contribution.getAttachContainerId()).to.be.undefined;
+        });
+
+        it('should ignore whitespace-only --attach-container', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'attach-container': '  ' }));
+            expect(contribution.getAttachContainerId()).to.be.undefined;
+        });
+    });
+
+    describe('consumeAttachContainerId', () => {
+
+        it('should return the container ID and clear it', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'attach-container': 'abc123' }));
+            expect(contribution.consumeAttachContainerId()).to.equal('abc123');
+            expect(contribution.consumeAttachContainerId()).to.be.undefined;
+            expect(contribution.getAttachContainerId()).to.be.undefined;
+        });
+
+        it('should return undefined when no ID was set', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs());
+            expect(contribution.consumeAttachContainerId()).to.be.undefined;
+        });
+    });
+
+    describe('shouldScanForDevJson', () => {
+
+        it('should default to true', () => {
+            const contribution = new DevContainerCliContribution();
+            expect(contribution.shouldScanForDevJson()).to.be.true;
+        });
+
+        it('should remain true when --dev-json is true', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'dev-json': true }));
+            expect(contribution.shouldScanForDevJson()).to.be.true;
+        });
+
+        it('should be false when --dev-json is false', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'dev-json': false }));
+            expect(contribution.shouldScanForDevJson()).to.be.false;
+        });
+
+        it('should be true when --dev-json is undefined', () => {
+            const contribution = new DevContainerCliContribution();
+            contribution.setArguments(createArgs({ 'dev-json': undefined }));
+            expect(contribution.shouldScanForDevJson()).to.be.true;
+        });
+    });
+});