@codingame/monaco-vscode-log-service-override 13.1.7 → 14.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-log-service-override",
-  "version": "13.1.7",
+  "version": "14.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - log service-override",
   "keywords": [],
@@ -15,11 +15,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-7b77bc98-d4d5-5442-b972-c926eb6db528-common": "13.1.7",
-    "@codingame/monaco-vscode-abed5a84-8a82-5f84-9412-88a736235bae-common": "13.1.7",
-    "@codingame/monaco-vscode-api": "13.1.7",
-    "@codingame/monaco-vscode-cea4d01f-6526-5c2f-8b09-b168fead499f-common": "13.1.7",
-    "@codingame/monaco-vscode-environment-service-override": "13.1.7"
+    "@codingame/monaco-vscode-abed5a84-8a82-5f84-9412-88a736235bae-common": "14.0.1",
+    "@codingame/monaco-vscode-api": "14.0.1",
+    "@codingame/monaco-vscode-cea4d01f-6526-5c2f-8b09-b168fead499f-common": "14.0.1",
+    "@codingame/monaco-vscode-environment-service-override": "14.0.1"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.d.ts

@@ -30,7 +30,6 @@ export declare class DefaultLogLevelsService extends Disposable implements IDefa
     private _getDefaultLogLevel;
     private _writeLogLevelsToArgv;
     private _parseLogLevelsFromArgv;
-    migrateLogLevels(): Promise<void>;
     private _readLogLevelsFromArgv;
     private _getDefaultLogLevelFromEnv;
     private _getExtensionsDefaultLogLevelsFromEnv;

package/vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js

@@ -112,16 +112,6 @@ let DefaultLogLevelsService = class DefaultLogLevelsService extends Disposable {
         }
         return !isUndefined(result.default) || result.extensions?.length ? result : undefined;
     }
-    async migrateLogLevels() {
-        const logLevels = await this._readLogLevelsFromArgv();
-        const regex = /^([^.]+\..+):(.+)$/;
-        if (( logLevels.some(extensionLogLevel => regex.test(extensionLogLevel)))) {
-            const argvLogLevel = await this._parseLogLevelsFromArgv();
-            if (argvLogLevel) {
-                await this._writeLogLevelsToArgv(argvLogLevel);
-            }
-        }
-    }
     async _readLogLevelsFromArgv() {
         try {
             const content = await this.fileService.readFile(this.environmentService.argvResource);

package/vscode/src/vs/workbench/contrib/logs/common/logs.contribution.js

@@ -4,21 +4,17 @@ import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls'
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
 import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { SetLogLevelAction } from '@codingame/monaco-vscode-7b77bc98-d4d5-5442-b972-c926eb6db528-common/vscode/vs/workbench/contrib/logs/common/logsActions';
+import { SetLogLevelAction } from './logsActions.js';
 import { Extensions as Extensions$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
-import { whenProviderRegistered } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
-import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output';
+import { Extensions, isSingleSourceOutputChannelDescriptor, isMultiSourceOutputChannelDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output';
 import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
-import { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { CONTEXT_LOG_LEVEL, LogLevelToString, isLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
-import { ILogService, ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { showWindowLogActionId, windowLogId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/log/common/logConstants';
-import { createCancelablePromise, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { isCancellationError, getErrorMessage, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { IDefaultLogLevelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
@@ -43,7 +39,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.setDefaultLogLevel',
-            title: ( localize2(7033, "Set Default Log Level")),
+            title: ( localize2(7176, "Set Default Log Level")),
             category: Categories.Developer,
         });
     }
@@ -52,16 +48,13 @@ registerAction2(class extends Action2 {
     }
 });
 let LogOutputChannels = class LogOutputChannels extends Disposable {
-    constructor(logService, loggerService, contextKeyService, fileService, uriIdentityService) {
+    constructor(loggerService, contextKeyService, uriIdentityService) {
         super();
-        this.logService = logService;
         this.loggerService = loggerService;
         this.contextKeyService = contextKeyService;
-        this.fileService = fileService;
         this.uriIdentityService = uriIdentityService;
         this.contextKeys = ( new CounterSet());
         this.outputChannelRegistry = ( Registry.as(Extensions.OutputChannels));
-        this.loggerDisposables = this._register(( new DisposableMap()));
         const contextKey = CONTEXT_LOG_LEVEL.bindTo(contextKeyService);
         contextKey.set(LogLevelToString(loggerService.getLogLevel()));
         this._register(loggerService.onDidChangeLogLevel(e => {
@@ -133,62 +126,55 @@ let LogOutputChannels = class LogOutputChannels extends Disposable {
         }
     }
     registerLogChannel(logger) {
+        if (logger.group) {
+            this.registerCompoundLogChannel(logger.group.id, logger.group.name, logger);
+            return;
+        }
         const channel = this.outputChannelRegistry.getChannel(logger.id);
-        if (channel && this.uriIdentityService.extUri.isEqual(channel.file, logger.resource)) {
+        if (channel && isSingleSourceOutputChannelDescriptor(channel) && this.uriIdentityService.extUri.isEqual(channel.source.resource, logger.resource)) {
             return;
         }
-        const disposables = ( new DisposableStore());
-        const promise = createCancelablePromise(async (token) => {
-            await whenProviderRegistered(logger.resource, this.fileService);
-            try {
-                await this.whenFileExists(logger.resource, 1, token);
-                const existingChannel = this.outputChannelRegistry.getChannel(logger.id);
-                const remoteLogger = existingChannel?.file?.scheme === Schemas.vscodeRemote ? this.loggerService.getRegisteredLogger(existingChannel.file) : undefined;
-                if (remoteLogger) {
-                    this.deregisterLogChannel(remoteLogger);
-                }
-                const hasToAppendRemote = existingChannel && logger.resource.scheme === Schemas.vscodeRemote;
-                const id = hasToAppendRemote ? `${logger.id}.remote` : logger.id;
-                const label = hasToAppendRemote ? ( localize(7034, "{0} (Remote)", logger.name ?? logger.id)) : logger.name ?? logger.id;
-                this.outputChannelRegistry.registerChannel({ id, label, file: logger.resource, log: true, extensionId: logger.extensionId });
-                disposables.add(toDisposable(() => this.outputChannelRegistry.removeChannel(id)));
-                if (remoteLogger) {
-                    this.registerLogChannel(remoteLogger);
-                }
-            }
-            catch (error) {
-                if (!isCancellationError(error)) {
-                    this.logService.error('Error while registering log channel', ( logger.resource.toString()), getErrorMessage(error));
-                }
+        const existingChannel = this.outputChannelRegistry.getChannel(logger.id);
+        const remoteLogger = existingChannel && isSingleSourceOutputChannelDescriptor(existingChannel) && existingChannel.source.resource.scheme === Schemas.vscodeRemote ? this.loggerService.getRegisteredLogger(existingChannel.source.resource) : undefined;
+        if (remoteLogger) {
+            this.deregisterLogChannel(remoteLogger);
+        }
+        const hasToAppendRemote = existingChannel && logger.resource.scheme === Schemas.vscodeRemote;
+        const id = hasToAppendRemote ? `${logger.id}.remote` : logger.id;
+        const label = hasToAppendRemote ? ( localize(7177, "{0} (Remote)", logger.name ?? logger.id)) : logger.name ?? logger.id;
+        this.outputChannelRegistry.registerChannel({ id, label, source: { resource: logger.resource }, log: true, extensionId: logger.extensionId });
+    }
+    registerCompoundLogChannel(id, name, logger) {
+        const channel = this.outputChannelRegistry.getChannel(id);
+        const source = { resource: logger.resource, name: logger.name ?? logger.id };
+        if (channel) {
+            if (isMultiSourceOutputChannelDescriptor(channel) && !( channel.source.some(
+                ({ resource }) => this.uriIdentityService.extUri.isEqual(resource, logger.resource)
+            ))) {
+                this.outputChannelRegistry.updateChannelSources(id, [...channel.source, source]);
             }
-        });
-        disposables.add(toDisposable(() => promise.cancel()));
-        this.loggerDisposables.set(( logger.resource.toString()), disposables);
+        }
+        else {
+            this.outputChannelRegistry.registerChannel({ id, label: name, log: true, source: [source] });
+        }
     }
     deregisterLogChannel(logger) {
-        this.loggerDisposables.deleteAndDispose(( logger.resource.toString()));
-    }
-    async whenFileExists(file, trial, token) {
-        const exists = await this.fileService.exists(file);
-        if (exists) {
-            return;
-        }
-        if (token.isCancellationRequested) {
-            throw ( new CancellationError());
+        if (logger.group) {
+            const channel = this.outputChannelRegistry.getChannel(logger.group.id);
+            if (channel && isMultiSourceOutputChannelDescriptor(channel)) {
+                this.outputChannelRegistry.updateChannelSources(logger.group.id, channel.source.filter(({ resource }) => !this.uriIdentityService.extUri.isEqual(resource, logger.resource)));
+            }
         }
-        if (trial > 10) {
-            throw ( new Error(`Timed out while waiting for file to be created`));
+        else {
+            this.outputChannelRegistry.removeChannel(logger.id);
         }
-        this.logService.debug(`[Registering Log Channel] File does not exist. Waiting for 1s to retry.`, ( file.toString()));
-        await timeout(1000, token);
-        await this.whenFileExists(file, trial + 1, token);
     }
     registerShowWindowLogAction() {
         this._register(registerAction2(class ShowWindowLogAction extends Action2 {
             constructor() {
                 super({
                     id: showWindowLogActionId,
-                    title: ( localize2(7035, "Show Window Log")),
+                    title: ( localize2(7178, "Show Window Log")),
                     category: Categories.Developer,
                     f1: true
                 });
@@ -201,19 +187,8 @@ let LogOutputChannels = class LogOutputChannels extends Disposable {
     }
 };
 LogOutputChannels = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, ILoggerService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IUriIdentityService))
+    ( __param(0, ILoggerService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IUriIdentityService))
 ], LogOutputChannels));
-let LogLevelMigration = class LogLevelMigration {
-    constructor(defaultLogLevelsService) {
-        defaultLogLevelsService.migrateLogLevels();
-    }
-};
-LogLevelMigration = ( __decorate([
-    ( __param(0, IDefaultLogLevelsService))
-], LogLevelMigration));
 ( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(LogOutputChannels, LifecyclePhase.Restored);
-( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(LogLevelMigration, LifecyclePhase.Eventually);

package/vscode/src/vs/workbench/contrib/logs/common/logsActions.d.ts

@@ -0,0 +1,36 @@
+import * as nls from "@codingame/monaco-vscode-api/vscode/vs/nls";
+import { Action } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { ILoggerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IOutputService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service";
+import { IDefaultLogLevelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service";
+export declare class SetLogLevelAction extends Action {
+    private readonly quickInputService;
+    private readonly loggerService;
+    private readonly outputService;
+    private readonly defaultLogLevelsService;
+    static readonly ID = "workbench.action.setLogLevel";
+    static readonly TITLE: nls.ILocalizedString;
+    constructor(id: string, label: string, quickInputService: IQuickInputService, loggerService: ILoggerService, outputService: IOutputService, defaultLogLevelsService: IDefaultLogLevelsService);
+    run(): Promise<void>;
+    private selectLogLevelOrChannel;
+    private setLogLevelForChannel;
+    private getLogLevelEntries;
+    private getLabel;
+    private getDescription;
+}
+export declare class OpenWindowSessionLogFileAction extends Action {
+    private readonly environmentService;
+    private readonly fileService;
+    private readonly quickInputService;
+    private readonly editorService;
+    static readonly ID = "workbench.action.openSessionLogFile";
+    static readonly TITLE: nls.ILocalizedString;
+    constructor(id: string, label: string, environmentService: IWorkbenchEnvironmentService, fileService: IFileService, quickInputService: IQuickInputService, editorService: IEditorService);
+    run(): Promise<void>;
+    private getSessions;
+    private getLogFiles;
+}

package/vscode/src/vs/workbench/contrib/logs/common/logsActions.js

@@ -0,0 +1,204 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { isLogLevel, LogLevel, LogLevelToLocalizedString } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { basename, dirname, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isSingleSourceOutputChannelDescriptor, isMultiSourceOutputChannelDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output';
+import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
+import { IDefaultLogLevelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+let SetLogLevelAction = class SetLogLevelAction extends Action {
+    static { this.ID = 'workbench.action.setLogLevel'; }
+    static { this.TITLE = ( localize2(7179, "Set Log Level...")); }
+    constructor(id, label, quickInputService, loggerService, outputService, defaultLogLevelsService) {
+        super(id, label);
+        this.quickInputService = quickInputService;
+        this.loggerService = loggerService;
+        this.outputService = outputService;
+        this.defaultLogLevelsService = defaultLogLevelsService;
+    }
+    async run() {
+        const logLevelOrChannel = await this.selectLogLevelOrChannel();
+        if (logLevelOrChannel !== null) {
+            if (isLogLevel(logLevelOrChannel)) {
+                this.loggerService.setLogLevel(logLevelOrChannel);
+            }
+            else {
+                await this.setLogLevelForChannel(logLevelOrChannel);
+            }
+        }
+    }
+    async selectLogLevelOrChannel() {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const extensionLogs = [], logs = [];
+        const logLevel = this.loggerService.getLogLevel();
+        for (const channel of this.outputService.getChannelDescriptors()) {
+            if (!this.outputService.canSetLogLevel(channel)) {
+                continue;
+            }
+            const sources = isSingleSourceOutputChannelDescriptor(channel) ? [channel.source] : isMultiSourceOutputChannelDescriptor(channel) ? channel.source : [];
+            if (!sources.length) {
+                continue;
+            }
+            const channelLogLevel = sources.reduce((prev, curr) => Math.min(prev, this.loggerService.getLogLevel(curr.resource) ?? logLevel), logLevel);
+            const item = {
+                id: channel.id,
+                label: channel.label,
+                description: channelLogLevel !== logLevel ? this.getLabel(channelLogLevel) : undefined,
+                channel
+            };
+            if (channel.extensionId) {
+                extensionLogs.push(item);
+            }
+            else {
+                logs.push(item);
+            }
+        }
+        const entries = [];
+        entries.push({ type: 'separator', label: ( localize(7180, "All")) });
+        entries.push(...this.getLogLevelEntries(defaultLogLevels.default, this.loggerService.getLogLevel(), true));
+        if (extensionLogs.length) {
+            entries.push({ type: 'separator', label: ( localize(7181, "Extension Logs")) });
+            entries.push(...extensionLogs.sort((a, b) => a.label.localeCompare(b.label)));
+        }
+        entries.push({ type: 'separator', label: ( localize(7182, "Logs")) });
+        entries.push(...logs.sort((a, b) => a.label.localeCompare(b.label)));
+        return (new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
+            quickPick.placeholder = ( localize(7183, "Set Log Level"));
+            quickPick.items = entries;
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                const result = selectedItem ? selectedItem.level ?? selectedItem : null;
+                disposables.dispose();
+                resolve(result);
+            }));
+            quickPick.show();
+        }));
+    }
+    async setLogLevelForChannel(logChannel) {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const defaultLogLevel = defaultLogLevels.extensions.find(e => e[0] === logChannel.channel.extensionId?.toLowerCase())?.[1] ?? defaultLogLevels.default;
+        const entries = this.getLogLevelEntries(defaultLogLevel, this.outputService.getLogLevel(logChannel.channel) ?? defaultLogLevel, !!logChannel.channel.extensionId);
+        return (new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = disposables.add(this.quickInputService.createQuickPick());
+            quickPick.placeholder = logChannel ? ( localize(7184, " {0}: Select log level", logChannel?.label)) : ( localize(7185, "Select log level"));
+            quickPick.items = entries;
+            quickPick.activeItems = entries.filter((entry) => entry.level === this.loggerService.getLogLevel());
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level, logChannel.channel.extensionId);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                if (selectedItem) {
+                    this.outputService.setLogLevel(logChannel.channel, selectedItem.level);
+                }
+                disposables.dispose();
+                resolve();
+            }));
+            quickPick.show();
+        }));
+    }
+    getLogLevelEntries(defaultLogLevel, currentLogLevel, canSetDefaultLogLevel) {
+        const button = canSetDefaultLogLevel ? { iconClass: ThemeIcon.asClassName(Codicon.checkAll), tooltip: ( localize(7186, "Set as Default Log Level")) } : undefined;
+        return [
+            { label: this.getLabel(LogLevel.Trace, currentLogLevel), level: LogLevel.Trace, description: this.getDescription(LogLevel.Trace, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Trace ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Debug, currentLogLevel), level: LogLevel.Debug, description: this.getDescription(LogLevel.Debug, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Debug ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Info, currentLogLevel), level: LogLevel.Info, description: this.getDescription(LogLevel.Info, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Info ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Warning, currentLogLevel), level: LogLevel.Warning, description: this.getDescription(LogLevel.Warning, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Warning ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Error, currentLogLevel), level: LogLevel.Error, description: this.getDescription(LogLevel.Error, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Error ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Off, currentLogLevel), level: LogLevel.Off, description: this.getDescription(LogLevel.Off, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Off ? [button] : undefined },
+        ];
+    }
+    getLabel(level, current) {
+        const label = LogLevelToLocalizedString(level).value;
+        return level === current ? `$(check) ${label}` : label;
+    }
+    getDescription(level, defaultLogLevel) {
+        return defaultLogLevel === level ? ( localize(7187, "Default")) : undefined;
+    }
+};
+SetLogLevelAction = ( __decorate([
+    ( __param(2, IQuickInputService)),
+    ( __param(3, ILoggerService)),
+    ( __param(4, IOutputService)),
+    ( __param(5, IDefaultLogLevelsService))
+], SetLogLevelAction));
+(class OpenWindowSessionLogFileAction extends Action {
+    static { this.ID = 'workbench.action.openSessionLogFile'; }
+    static { this.TITLE = ( localize2(7188, "Open Window Log File (Session)...")); }
+    constructor(id, label, environmentService, fileService, quickInputService, editorService) {
+        super(id, label);
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.quickInputService = quickInputService;
+        this.editorService = editorService;
+    }
+    async run() {
+        const sessionResult = await this.quickInputService.pick(this.getSessions().then(sessions => ( sessions.map((s, index) => ({
+            id: ( s.toString()),
+            label: basename(s),
+            description: index === 0 ? ( localize(7189, "Current")) : undefined
+        })))), {
+            canPickMany: false,
+            placeHolder: ( localize(7190, "Select Session"))
+        });
+        if (sessionResult) {
+            const logFileResult = await this.quickInputService.pick(this.getLogFiles(( URI.parse(sessionResult.id))).then(logFiles => ( logFiles.map((s) => ({
+                id: ( s.toString()),
+                label: basename(s)
+            })))), {
+                canPickMany: false,
+                placeHolder: ( localize(7191, "Select Log file"))
+            });
+            if (logFileResult) {
+                return this.editorService.openEditor({ resource: ( URI.parse(logFileResult.id)), options: { pinned: true } }).then(() => undefined);
+            }
+        }
+    }
+    async getSessions() {
+        const logsPath = this.environmentService.logsHome.with({ scheme: this.environmentService.logFile.scheme });
+        const result = [logsPath];
+        const stat = await this.fileService.resolve(dirname(logsPath));
+        if (stat.children) {
+            result.push(...( stat.children
+                .filter(stat => !isEqual(stat.resource, logsPath) && stat.isDirectory && /^\d{8}T\d{6}$/.test(stat.name))
+                .sort()
+                .reverse()
+                .map(d => d.resource)));
+        }
+        return result;
+    }
+    async getLogFiles(session) {
+        const stat = await this.fileService.resolve(session);
+        if (stat.children) {
+            return ( stat.children.filter(stat => !stat.isDirectory).map(stat => stat.resource));
+        }
+        return [];
+    }
+});
+
+export { SetLogLevelAction };