@theia/plugin-ext 1.40.1 → 1.41.0

package/src/plugin/plugin-context.ts

@@ -98,6 +98,7 @@ import {
     DataTransfer,
     TreeItem,
     TreeItemCollapsibleState,
+    TreeItemCheckboxState,
     DocumentSymbol,
     SymbolTag,
     WorkspaceEdit,
@@ -165,8 +166,8 @@ import {
     InlayHintKind,
     InlayHintLabelPart,
     TelemetryTrustedValue,
-    NotebookCell,
     NotebookCellKind,
+    NotebookCellExecutionState,
     NotebookCellStatusBarAlignment,
     NotebookEditorRevealType,
     NotebookControllerAffinity,
@@ -174,10 +175,11 @@ import {
     NotebookCellOutput,
     NotebookCellOutputItem,
     NotebookData,
-    NotebookDocument,
     NotebookRange,
     NotebookCellStatusBarItem,
     NotebookEdit,
+    NotebookKernelSourceAction,
+    NotebookRendererScript,
     TestRunProfileKind,
     TestTag,
     TestRunRequest,
@@ -242,7 +244,13 @@ import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import { FilePermission } from '@theia/filesystem/lib/common/files';
 import { TabsExtImpl } from './tabs';
 import { LocalizationExtImpl } from './localization-ext';
+import { NotebooksExtImpl } from './notebook/notebooks';
 import { TelemetryExtImpl } from './telemetry-ext';
+import { NotebookDocument } from './notebook/notebook-document';
+import { NotebookRenderersExtImpl } from './notebook/notebook-renderers';
+import { NotebookKernelsExtImpl } from './notebook/notebook-kernels';
+import { NotebookDocumentsExtImpl } from './notebook/notebook-documents';
+import { NotebookEditorsExtImpl } from './notebook/notebook-editors';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -266,6 +274,11 @@ export function createAPIFactory(
     const notificationExt = rpc.set(MAIN_RPC_CONTEXT.NOTIFICATION_EXT, new NotificationExtImpl(rpc));
     const editors = rpc.set(MAIN_RPC_CONTEXT.TEXT_EDITORS_EXT, new TextEditorsExtImpl(rpc, editorsAndDocumentsExt));
     const documents = rpc.set(MAIN_RPC_CONTEXT.DOCUMENTS_EXT, new DocumentsExtImpl(rpc, editorsAndDocumentsExt));
+    const notebooksExt = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOKS_EXT, new NotebooksExtImpl(rpc, commandRegistry, editorsAndDocumentsExt, documents));
+    const notebookEditors = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_EDITORS_EXT, new NotebookEditorsExtImpl(notebooksExt));
+    const notebookRenderers = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_RENDERERS_EXT, new NotebookRenderersExtImpl(rpc, notebooksExt));
+    const notebookKernels = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_KERNELS_EXT, new NotebookKernelsExtImpl(rpc, notebooksExt, commandRegistry));
+    const notebookDocuments = rpc.set(MAIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_EXT, new NotebookDocumentsExtImpl(notebooksExt));
     const statusBarMessageRegistryExt = new StatusBarMessageRegistryExt(rpc);
     const terminalExt = rpc.set(MAIN_RPC_CONTEXT.TERMINAL_EXT, new TerminalServiceExtImpl(rpc));
     const outputChannelRegistryExt = rpc.set(MAIN_RPC_CONTEXT.OUTPUT_CHANNEL_REGISTRY_EXT, new OutputChannelRegistryExtImpl(rpc));
@@ -427,24 +440,24 @@ export function createAPIFactory(
                 }
             },
             get visibleNotebookEditors(): theia.NotebookEditor[] {
-                return [] as theia.NotebookEditor[];
+                return notebooksExt.visibleApiNotebookEditors;
             },
             onDidChangeVisibleNotebookEditors(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidChangeVisibleNotebookEditors(listener, thisArg, disposables);
             },
             get activeNotebookEditor(): theia.NotebookEditor | undefined {
-                return undefined;
+                return notebooksExt.activeApiNotebookEditor;
             }, onDidChangeActiveNotebookEditor(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidChangeActiveNotebookEditor(listener, thisArg, disposables);
             },
             onDidChangeNotebookEditorSelection(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebookEditors.onDidChangeNotebookEditorSelection(listener, thisArg, disposables);
             },
             onDidChangeNotebookEditorVisibleRanges(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebookEditors.onDidChangeNotebookEditorVisibleRanges(listener, thisArg, disposables);
             },
-            showNotebookDocument(document: NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
-                return Promise.resolve({} as theia.NotebookEditor);
+            showNotebookDocument(document: theia.NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
+                return notebooksExt.showNotebookDocument(document, options);
             },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             showQuickPick(items: any, options?: theia.QuickPickOptions, token?: theia.CancellationToken): any {
@@ -616,7 +629,7 @@ export function createAPIFactory(
                 return workspaceExt.onDidChangeWorkspaceFolders(listener, thisArg, disposables);
             },
             get notebookDocuments(): theia.NotebookDocument[] {
-                return [] as theia.NotebookDocument[];
+                return notebooksExt.getAllApiDocuments();
             },
             get textDocuments(): theia.TextDocument[] {
                 return documents.getAllDocumentData().map(data => data.document);
@@ -628,19 +641,19 @@ export function createAPIFactory(
                 return documents.onDidRemoveDocument(listener, thisArg, disposables);
             },
             onDidOpenNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidOpenNotebookDocument(listener, thisArg, disposables);
             },
             onDidCloseNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
-            },
-            onDidChangeNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+                return notebooksExt.onDidCloseNotebookDocument(listener, thisArg, disposables);
             },
             onWillSaveNotebookDocument(listener, thisArg?, disposables?) {
                 return Disposable.NULL;
             },
-            onDidSaveNotebookDocument(listener, thisArg?, disposables?) {
-                return Disposable.NULL;
+            onDidSaveNotebookDocument(listener, thisArg, disposables) {
+                return notebookDocuments.onDidSaveNotebookDocument(listener, thisArg, disposables);
+            },
+            onDidChangeNotebookDocument(listener, thisArg, disposables) {
+                return notebookDocuments.onDidChangeNotebookDocument(listener, thisArg, disposables);
             },
             onDidOpenTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidAddDocument(listener, thisArg, disposables);
@@ -686,8 +699,18 @@ export function createAPIFactory(
                 const data = await documents.openDocument(uri);
                 return data && data.document;
             },
-            openNotebookDocument(uriOrString: theia.Uri | string, content?: NotebookData): Promise<theia.NotebookDocument | undefined> {
-                return Promise.reject(new Error('Notebook API is stubbed'));
+            async openNotebookDocument(uriOrType: theia.Uri | string, content?: NotebookData): Promise<theia.NotebookDocument | undefined> {
+                let uri: URI;
+                if (URI.isUri(uriOrType)) {
+                    uri = uriOrType;
+                    await notebooksExt.openNotebookDocument(uriOrType as URI);
+                } else if (typeof uriOrType === 'string') {
+                    uri = URI.revive(await notebooksExt.createNotebookDocument({ viewType: uriOrType, content }));
+                } else {
+                    throw new Error('Invalid arguments');
+                }
+                return notebooksExt.getNotebookDocument(uri).apiNotebook;
+
             },
             createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): theia.FileSystemWatcher =>
                 extHostFileSystemEvent.createFileSystemWatcher(fromGlobPattern(pattern), ignoreCreate, ignoreChange, ignoreDelete),
@@ -729,7 +752,7 @@ export function createAPIFactory(
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
             },
             registerNotebookSerializer(notebookType: string, serializer: theia.NotebookSerializer, options?: theia.NotebookDocumentContentOptions): theia.Disposable {
-                return Disposable.NULL;
+                return notebooksExt.registerNotebookSerializer(plugin, notebookType, serializer, options);
             },
             get isTrusted(): boolean {
                 return workspaceExt.trusted;
@@ -1156,54 +1179,27 @@ export function createAPIFactory(
                 label,
                 handler?: (cells: theia.NotebookCell[],
                     notebook: theia.NotebookDocument,
-                    controller: theia.NotebookController) => void | Thenable<void>
+                    controller: theia.NotebookController) => void | Thenable<void>,
+                rendererScripts?: NotebookRendererScript[]
             ) {
-                return {
-                    id,
-                    notebookType,
-                    label,
-                    handler,
-                    createNotebookCellExecution: (cell: NotebookCell) => ({
-                        cell,
-                        token: CancellationToken.None,
-                        executionOrder: undefined,
-                        start: () => undefined,
-                        end: () => undefined,
-                        clearOutput: () => ({} as Thenable<void>),
-                        replaceOutput: () => ({} as Thenable<void>),
-                        appendOutput: () => ({} as Thenable<void>),
-                        replaceOutputItems: () => ({} as Thenable<void>),
-                        appendOutputItems: () => ({} as Thenable<void>)
-                    }),
-                    executeHandler(
-                        cells: theia.NotebookCell[],
-                        notebook: theia.NotebookDocument,
-                        controller: theia.NotebookController
-                    ): (void | Thenable<void>) { },
-                    onDidChangeSelectedNotebooks: () => Disposable.create(() => { }),
-                    updateNotebookAffinity: (notebook: theia.NotebookDocument, affinity: theia.NotebookControllerAffinity) => undefined,
-                    dispose: () => undefined,
-                };
-
+                return notebookKernels.createNotebookController(plugin.model.id, id, notebookType, label, handler, rendererScripts);
             },
-            createRendererMessaging(
-                rendererId
-            ) {
-                return {
-                    rendererId,
-                    onDidReceiveMessage: () => Disposable.create(() => { }),
-                    postMessage: () => Promise.resolve({}),
-                };
+            createRendererMessaging(rendererId) {
+                return notebookRenderers.createRendererMessaging(rendererId);
             },
             registerNotebookCellStatusBarItemProvider(
                 notebookType,
                 provider
             ) {
-                return {
-                    notebookType,
-                    provider,
-                    dispose: () => undefined,
-                };
+                return notebooksExt.registerNotebookCellStatusBarItemProvider(notebookType, provider);
+            },
+            onDidChangeNotebookCellExecutionState: notebookKernels.onDidChangeNotebookCellExecutionState,
+
+            createNotebookControllerDetectionTask(notebookType: string) {
+                return notebookKernels.createNotebookControllerDetectionTask(notebookType);
+            },
+            registerKernelSourceActionProvider(notebookType: string, provider: theia.NotebookKernelSourceActionProvider) {
+                return notebookKernels.registerKernelSourceActionProvider(notebookType, provider);
             }
         };
 
@@ -1291,6 +1287,7 @@ export function createAPIFactory(
             DataTransfer,
             TreeItem,
             TreeItemCollapsibleState,
+            TreeItemCheckboxState,
             SymbolKind,
             SymbolTag,
             DocumentSymbol,
@@ -1357,6 +1354,7 @@ export function createAPIFactory(
             InlayHintLabelPart,
             TelemetryTrustedValue,
             NotebookCellData,
+            NotebookCellExecutionState,
             NotebookCellKind,
             NotebookCellOutput,
             NotebookCellOutputItem,
@@ -1368,6 +1366,8 @@ export function createAPIFactory(
             NotebookDocument,
             NotebookRange,
             NotebookEdit,
+            NotebookKernelSourceAction,
+            NotebookRendererScript,
             TestRunProfileKind,
             TestTag,
             TestRunRequest,
@@ -1420,6 +1420,8 @@ export interface ExtensionPlugin<T> extends theia.Plugin<T> {
 }
 
 export class Plugin<T> implements theia.Plugin<T> {
+    #pluginManager: PluginManager;
+
     id: string;
     pluginPath: string;
     pluginUri: theia.Uri;
@@ -1427,7 +1429,9 @@ export class Plugin<T> implements theia.Plugin<T> {
     packageJSON: any;
     pluginType: theia.PluginType;
 
-    constructor(protected readonly pluginManager: PluginManager, plugin: InternalPlugin) {
+    constructor(pluginManager: PluginManager, plugin: InternalPlugin) {
+        this.#pluginManager = pluginManager;
+
         this.id = plugin.model.id;
         this.pluginPath = plugin.pluginFolder;
         this.packageJSON = plugin.rawModel;
@@ -1442,26 +1446,29 @@ export class Plugin<T> implements theia.Plugin<T> {
     }
 
     get isActive(): boolean {
-        return this.pluginManager.isActive(this.id);
+        return this.#pluginManager.isActive(this.id);
     }
 
     get exports(): T {
-        return <T>this.pluginManager.getPluginExport(this.id);
+        return <T>this.#pluginManager.getPluginExport(this.id);
     }
 
     activate(): PromiseLike<T> {
-        return this.pluginManager.activatePlugin(this.id).then(() => this.exports);
+        return this.#pluginManager.activatePlugin(this.id).then(() => this.exports);
     }
 }
 
 export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
+    #pluginManager: PluginManager;
+
     extensionPath: string;
     extensionUri: theia.Uri;
     extensionKind: ExtensionKind;
     isFromDifferentExtensionHost: boolean;
 
-    constructor(protected override readonly pluginManager: PluginManager, plugin: InternalPlugin, isFromDifferentExtensionHost = false) {
+    constructor(pluginManager: PluginManager, plugin: InternalPlugin, isFromDifferentExtensionHost = false) {
         super(pluginManager, plugin);
+        this.#pluginManager = pluginManager;
 
         this.extensionPath = this.pluginPath;
         this.extensionUri = this.pluginUri;
@@ -1470,14 +1477,14 @@ export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
     }
 
     override get isActive(): boolean {
-        return this.pluginManager.isActive(this.id);
+        return this.#pluginManager.isActive(this.id);
     }
 
     override get exports(): T {
-        return <T>this.pluginManager.getPluginExport(this.id);
+        return <T>this.#pluginManager.getPluginExport(this.id);
     }
 
     override activate(): PromiseLike<T> {
-        return this.pluginManager.activatePlugin(this.id).then(() => this.exports);
+        return this.#pluginManager.activatePlugin(this.id).then(() => this.exports);
     }
 }

package/src/plugin/plugin-manager.ts

@@ -43,6 +43,7 @@ import { WebviewsExtImpl } from './webviews';
 import { URI as Uri } from './types-impl';
 import { SecretsExtImpl, SecretStorageExt } from '../plugin/secrets-ext';
 import { PluginExt } from './plugin-context';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export interface PluginHost {
 
@@ -96,7 +97,9 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         'onFileSystem',
         'onCustomEditor',
         'onStartupFinished',
-        'onAuthenticationRequest'
+        'onAuthenticationRequest',
+        'onNotebook',
+        'onNotebookSerializer'
     ]);
 
     private configStorage: ConfigStorage | undefined;
@@ -115,6 +118,7 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     }
 
     protected jsonValidation: PluginJsonValidationContribution[] = [];
+    protected ready = new Deferred();
 
     constructor(
         private readonly host: PluginHost,
@@ -230,6 +234,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
             this.registerPlugin(plugin);
         }
 
+        // ensure plugins are registered before running activation events
+        this.ready.resolve();
         // run eager plugins
         await this.$activateByEvent('*');
         for (const activationEvent of params.activationEvents) {
@@ -333,6 +339,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     }
 
     async $activateByEvent(activationEvent: string): Promise<void> {
+        // Prevent the plugin manager from performing activations before plugins are registered
+        await this.ready.promise;
         if (activationEvent.endsWith(':*')) {
             const baseEvent = activationEvent.substring(0, activationEvent.length - 2);
             await this.activateByBaseEvent(baseEvent);

package/src/plugin/tasks/task-provider.ts

@@ -15,17 +15,17 @@
 // *****************************************************************************
 
 import * as theia from '@theia/plugin';
-import * as Converter from '../type-converters';
 import { TaskDto } from '../../common';
+import * as Converter from '../type-converters';
 
 export class TaskProviderAdapter {
 
     constructor(private readonly provider: theia.TaskProvider) { }
 
-    provideTasks(token: theia.CancellationToken): Promise<TaskDto[] | undefined> {
+    provideTasks(token: theia.CancellationToken): Promise<TaskDto[]> {
         return Promise.resolve(this.provider.provideTasks(token)).then(tasks => {
             if (!Array.isArray(tasks)) {
-                return undefined;
+                return [];
             }
             const result: TaskDto[] = [];
             for (const task of tasks) {
@@ -40,21 +40,18 @@ export class TaskProviderAdapter {
         });
     }
 
-    resolveTask(task: TaskDto, token: theia.CancellationToken): Promise<TaskDto | undefined> {
+    async resolveTask(task: TaskDto, token: theia.CancellationToken): Promise<TaskDto> {
         if (typeof this.provider.resolveTask !== 'function') {
-            return Promise.resolve(undefined);
+            return task;
         }
 
         const item = Converter.toTask(task);
         if (!item) {
-            return Promise.resolve(undefined);
+            return task;
         }
 
-        return Promise.resolve(this.provider.resolveTask(item, token)).then(value => {
-            if (value) {
-                return Converter.fromTask(value);
-            }
-            return undefined;
-        });
+        const resolved = await this.provider.resolveTask(item, token);
+        const converted = resolved ? Converter.fromTask(resolved) : Converter.fromTask(item);
+        return converted ?? task;
     }
 }

package/src/plugin/tasks/tasks.ts

@@ -158,37 +158,42 @@ export class TasksExtImpl implements TasksExt {
         throw new Error('Task was not successfully transformed into a task config');
     }
 
-    $provideTasks(handle: number): Promise<TaskDto[] | undefined> {
+    async $provideTasks(handle: number): Promise<TaskDto[]> {
         const adapter = this.adaptersMap.get(handle);
         if (adapter) {
             return adapter.provideTasks(CancellationToken.None).then(tasks => {
-                if (tasks) {
-                    for (const task of tasks) {
-                        if (task.taskType === 'customExecution') {
-                            task.executionId = this.addCustomExecution(task.callback);
-                            task.callback = undefined;
-                        }
+                for (const task of tasks) {
+                    if (task.taskType === 'customExecution') {
+                        this.applyCustomExecution(task);
                     }
                 }
                 return tasks;
             });
         } else {
-            return Promise.reject(new Error('No adapter found to provide tasks'));
+            throw new Error('No adapter found to provide tasks');
         }
     }
 
-    $resolveTask(handle: number, task: TaskDto, token: theia.CancellationToken): Promise<TaskDto | undefined> {
+    async $resolveTask(handle: number, task: TaskDto, token: theia.CancellationToken): Promise<TaskDto> {
         const adapter = this.adaptersMap.get(handle);
         if (adapter) {
             return adapter.resolveTask(task, token).then(resolvedTask => {
-                if (resolvedTask && resolvedTask.taskType === 'customExecution') {
-                    resolvedTask.executionId = this.addCustomExecution(resolvedTask.callback);
-                    resolvedTask.callback = undefined;
+                // ensure we do not lose task type and execution id during resolution as we need it for custom execution
+                resolvedTask.taskType = resolvedTask.taskType ?? task.taskType;
+                if (resolvedTask.taskType === 'customExecution') {
+                    this.applyCustomExecution(resolvedTask);
                 }
                 return resolvedTask;
             });
         } else {
-            return Promise.reject(new Error('No adapter found to resolve task'));
+            throw new Error('No adapter found to resolve task');
+        }
+    }
+
+    private applyCustomExecution(task: TaskDto): void {
+        if (task.callback) {
+            task.executionId = this.addCustomExecution(task.callback);
+            task.callback = undefined;
         }
     }
 

package/src/plugin/terminal-ext.ts

@@ -20,6 +20,7 @@ import { RPCProtocol } from '../common/rpc-protocol';
 import { Event, Emitter } from '@theia/core/lib/common/event';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import * as theia from '@theia/plugin';
+import * as Converter from './type-converters';
 import { Disposable, EnvironmentVariableMutatorType, TerminalExitReason, ThemeIcon } from './types-impl';
 import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
 import { ProvidedTerminalLink } from '../common/plugin-api-rpc-model';
@@ -313,7 +314,11 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private syncEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
         const serialized = [...collection.map.entries()];
-        this.proxy.$setEnvironmentVariableCollection(extensionIdentifier, collection.persistent, serialized.length === 0 ? undefined : serialized);
+        this.proxy.$setEnvironmentVariableCollection(collection.persistent, {
+            extensionIdentifier,
+            collection: serialized.length === 0 ? undefined : serialized,
+            description: Converter.fromMarkdownOrString(collection.description)
+        });
     }
 
     private setEnvironmentVariableCollection(extensionIdentifier: string, collection: EnvironmentVariableCollection): void {
@@ -339,8 +344,15 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
 export class EnvironmentVariableCollection implements theia.EnvironmentVariableCollection {
     readonly map: Map<string, theia.EnvironmentVariableMutator> = new Map();
+    private _description?: string | theia.MarkdownString;
     private _persistent: boolean = true;
 
+    public get description(): string | theia.MarkdownString | undefined { return this._description; }
+    public set description(value: string | theia.MarkdownString | undefined) {
+        this._description = value;
+        this.onDidChangeCollectionEmitter.fire();
+    }
+
     public get persistent(): boolean { return this._persistent; }
     public set persistent(value: boolean) {
         this._persistent = value;

package/src/plugin/tree/tree-views.ts

@@ -18,14 +18,14 @@
 
 import {
     TreeDataProvider, TreeView, TreeViewExpansionEvent, TreeItem, TreeItemLabel,
-    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken, DataTransferFile, TreeViewOptions, ViewBadge
+    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken, DataTransferFile, TreeViewOptions, ViewBadge, TreeCheckboxChangeEvent
 } from '@theia/plugin';
 // TODO: extract `@theia/util` for event, disposable, cancellation and common types
 // don't use @theia/core directly from plugin host
 import { Emitter } from '@theia/core/lib/common/event';
 import { basename } from '@theia/core/lib/common/paths';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { DataTransfer, DataTransferItem, Disposable as PluginDisposable, ThemeIcon } from '../types-impl';
+import { DataTransfer, DataTransferItem, Disposable as PluginDisposable, ThemeIcon, TreeItemCheckboxState } from '../types-impl';
 import { Plugin, PLUGIN_RPC_CONTEXT, TreeViewsExt, TreeViewsMain, TreeViewItem, TreeViewRevealOptions, DataTransferFileDTO } from '../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { CommandRegistryImpl, CommandsConverter } from '../command-registry';
@@ -33,6 +33,7 @@ import { TreeViewItemReference } from '../../common';
 import { PluginIconPath } from '../plugin-icon-path';
 import { URI } from '@theia/core/shared/vscode-uri';
 import { UriComponents } from '@theia/core/lib/common/uri';
+import { isObject } from '@theia/core';
 
 export class TreeViewsExtImpl implements TreeViewsExt {
     private proxy: TreeViewsMain;
@@ -54,6 +55,9 @@ export class TreeViewsExtImpl implements TreeViewsExt {
             }
         });
     }
+    $checkStateChanged(treeViewId: string, itemIds: { id: string; checked: boolean; }[]): Promise<void> {
+        return this.getTreeView(treeViewId).checkStateChanged(itemIds);
+    }
     $dragStarted(treeViewId: string, treeItemIds: string[], token: CancellationToken): Promise<UriComponents[] | undefined> {
         return this.getTreeView(treeViewId).onDragStarted(treeItemIds, token);
     }
@@ -107,6 +111,9 @@ export class TreeViewsExtImpl implements TreeViewsExt {
             get onDidChangeVisibility() {
                 return treeView.onDidChangeVisibility;
             },
+            get onDidChangeCheckboxState() {
+                return treeView.onDidChangeCheckboxState;
+            },
             get message(): string {
                 return treeView.message;
             },
@@ -211,6 +218,9 @@ class TreeViewExtImpl<T> implements Disposable {
     private readonly onDidChangeVisibilityEmitter = new Emitter<TreeViewVisibilityChangeEvent>();
     readonly onDidChangeVisibility = this.onDidChangeVisibilityEmitter.event;
 
+    private readonly onDidChangeCheckboxStateEmitter = new Emitter<TreeCheckboxChangeEvent<T>>();
+    readonly onDidChangeCheckboxState = this.onDidChangeCheckboxStateEmitter.event;
+
     private readonly nodes = new Map<string, TreeExtNode<T>>();
     private pendingRefresh = Promise.resolve();
 
@@ -234,7 +244,12 @@ class TreeViewExtImpl<T> implements Disposable {
         // make copies of optionally provided MIME types:
         const dragMimeTypes = options.dragAndDropController?.dragMimeTypes?.slice();
         const dropMimeTypes = options.dragAndDropController?.dropMimeTypes?.slice();
-        proxy.$registerTreeDataProvider(treeViewId, { showCollapseAll: options.showCollapseAll, canSelectMany: options.canSelectMany, dragMimeTypes, dropMimeTypes });
+        proxy.$registerTreeDataProvider(treeViewId, {
+            manageCheckboxStateManually: options.manageCheckboxStateManually,
+            showCollapseAll: options.showCollapseAll,
+            canSelectMany: options.canSelectMany,
+            dragMimeTypes, dropMimeTypes
+        });
         this.toDispose.push(Disposable.create(() => this.proxy.$unregisterTreeDataProvider(treeViewId)));
         options.treeDataProvider.onDidChangeTreeData?.(() => {
             this.pendingRefresh = proxy.$refresh(treeViewId);
@@ -399,7 +414,7 @@ class TreeViewExtImpl<T> implements Disposable {
                 const treeItem = await this.options.treeDataProvider.getTreeItem(value);
                 // Convert theia.TreeItem to the TreeViewItem
 
-                const label = this.getItemLabel(treeItem);
+                const label = this.getItemLabel(treeItem) || '';
                 const highlights = this.getTreeItemLabelHighlights(treeItem);
 
                 // Generate the ID
@@ -433,7 +448,22 @@ class TreeViewExtImpl<T> implements Disposable {
                     iconUrl = PluginIconPath.toUrl(<PluginIconPath | undefined>iconPath, this.plugin);
                 }
 
-                const treeViewItem = {
+                let checkboxInfo;
+                if (treeItem.checkboxState === undefined) {
+                    checkboxInfo = undefined;
+                } else if (isObject(treeItem.checkboxState)) {
+                    checkboxInfo = {
+                        checked: treeItem.checkboxState.state === TreeItemCheckboxState.Checked,
+                        tooltip: treeItem.checkboxState.tooltip,
+                        accessibilityInformation: treeItem.accessibilityInformation
+                    };
+                } else {
+                    checkboxInfo = {
+                        checked: treeItem.checkboxState === TreeItemCheckboxState.Checked
+                    };
+                }
+
+                const treeViewItem: TreeViewItem = {
                     id,
                     label,
                     highlights,
@@ -443,11 +473,12 @@ class TreeViewExtImpl<T> implements Disposable {
                     description: treeItem.description,
                     resourceUri: treeItem.resourceUri,
                     tooltip: treeItem.tooltip,
-                    collapsibleState: treeItem.collapsibleState,
+                    collapsibleState: treeItem.collapsibleState?.valueOf(),
+                    checkboxInfo: checkboxInfo,
                     contextValue: treeItem.contextValue,
                     command: this.commandsConverter.toSafeCommand(treeItem.command, toDisposeElement),
                     accessibilityInformation: treeItem.accessibilityInformation
-                } as TreeViewItem;
+                };
                 node.treeViewItem = treeViewItem;
 
                 return treeViewItem;
@@ -511,6 +542,25 @@ class TreeViewExtImpl<T> implements Disposable {
         }
     }
 
+    async checkStateChanged(items: readonly { id: string; checked: boolean; }[]): Promise<void> {
+        const transformed: [T, TreeItemCheckboxState][] = [];
+        items.forEach(item => {
+            const node = this.nodes.get(item.id);
+            if (node) {
+                if (node.value) {
+                    transformed.push([node.value, item.checked ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked]);
+                }
+                if (node.treeViewItem) {
+                    node.treeViewItem.checkboxInfo!.checked = item.checked;
+                }
+            }
+        });
+
+        this.onDidChangeCheckboxStateEmitter.fire({
+            items: transformed
+        });
+    }
+
     async resolveTreeItem(treeItemId: string, token: CancellationToken): Promise<TreeViewItem | undefined> {
         if (!this.options.treeDataProvider.resolveTreeItem) {
             return undefined;