@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/sessions/contrib/chat/browser/newSession.js

@@ -0,0 +1,274 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+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';
+
+const REPOSITORY_OPTION_ID = "repository";
+const BRANCH_OPTION_ID = "branch";
+const ISOLATION_OPTION_ID = "isolation";
+let LocalNewSession = class LocalNewSession extends Disposable {
+    get repoUri() {
+        return this._repoUri;
+    }
+    get isolationMode() {
+        return this._isolationMode;
+    }
+    get branch() {
+        return this._branch;
+    }
+    get modelId() {
+        return this._modelId;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get disabled() {
+        if (!this._repoUri) {
+            return true;
+        }
+        if (this._isolationMode === "worktree" && !this._branch) {
+            return true;
+        }
+        return false;
+    }
+    constructor(resource, defaultRepoUri, chatSessionsService, logService) {
+        super();
+        this.resource = resource;
+        this.chatSessionsService = chatSessionsService;
+        this.logService = logService;
+        this._isolationMode = "worktree";
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.target = AgentSessionProviders.Background;
+        this.selectedOptions = ( new Map());
+        if (defaultRepoUri) {
+            this._repoUri = defaultRepoUri;
+            this.setOption(REPOSITORY_OPTION_ID, defaultRepoUri.fsPath);
+        }
+    }
+    setRepoUri(uri) {
+        this._repoUri = uri;
+        this._isolationMode = "workspace";
+        this._branch = undefined;
+        this._onDidChange.fire("repoUri");
+        this._onDidChange.fire("disabled");
+        this.setOption(REPOSITORY_OPTION_ID, uri.fsPath);
+    }
+    setIsolationMode(mode) {
+        if (this._isolationMode !== mode) {
+            this._isolationMode = mode;
+            this._onDidChange.fire("isolationMode");
+            this._onDidChange.fire("disabled");
+            this.setOption(ISOLATION_OPTION_ID, mode);
+        }
+    }
+    setBranch(branch) {
+        if (this._branch !== branch) {
+            this._branch = branch;
+            this._onDidChange.fire("branch");
+            this._onDidChange.fire("disabled");
+            this.setOption(BRANCH_OPTION_ID, branch ?? "");
+        }
+    }
+    setModelId(modelId) {
+        this._modelId = modelId;
+    }
+    setQuery(query) {
+        this._query = query;
+    }
+    setAttachedContext(context) {
+        this._attachedContext = context;
+    }
+    setOption(optionId, value) {
+        if (typeof value === "string") {
+            this.selectedOptions.set(optionId, {
+                id: value,
+                name: value
+            });
+        } else {
+            this.selectedOptions.set(optionId, value);
+        }
+        this.chatSessionsService.notifySessionOptionsChange(this.resource, [{
+            optionId,
+            value
+        }]).catch(
+            err => this.logService.error(`Failed to notify session option ${optionId} change:`, err)
+        );
+    }
+};
+LocalNewSession = ( __decorate([( __param(2, IChatSessionsService)), ( __param(3, ILogService))], LocalNewSession));
+let RemoteNewSession = class RemoteNewSession extends Disposable {
+    get repoUri() {
+        return this._repoUri;
+    }
+    get isolationMode() {
+        return "worktree";
+    }
+    get branch() {
+        return undefined;
+    }
+    get modelId() {
+        return this._modelId;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get disabled() {
+        return !this._repoUri && !( this.selectedOptions.has("repositories"));
+    }
+    constructor(resource, target, chatSessionsService, contextKeyService, logService) {
+        super();
+        this.resource = resource;
+        this.target = target;
+        this.chatSessionsService = chatSessionsService;
+        this.contextKeyService = contextKeyService;
+        this.logService = logService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeOptionGroups = this._register(( new Emitter()));
+        this.onDidChangeOptionGroups = this._onDidChangeOptionGroups.event;
+        this.selectedOptions = ( new Map());
+        this._whenClauseKeys = ( new Set());
+        this._updateWhenClauseKeys();
+        this._register(this.chatSessionsService.onDidChangeOptionGroups(() => {
+            this._updateWhenClauseKeys();
+            this._onDidChangeOptionGroups.fire();
+            this._onDidChange.fire("options");
+        }));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (this._whenClauseKeys.size > 0 && e.affectsSome(this._whenClauseKeys)) {
+                this._onDidChangeOptionGroups.fire();
+            }
+        }));
+    }
+    setRepoUri(uri) {
+        this._repoUri = uri;
+        this._onDidChange.fire("repoUri");
+        this._onDidChange.fire("disabled");
+        this.setOption("repository", uri.fsPath);
+    }
+    setIsolationMode(_mode) {}
+    setBranch(_branch) {}
+    setModelId(modelId) {
+        this._modelId = modelId;
+    }
+    setQuery(query) {
+        this._query = query;
+    }
+    setAttachedContext(context) {
+        this._attachedContext = context;
+    }
+    setOption(optionId, value) {
+        if (typeof value !== "string") {
+            this.selectedOptions.set(optionId, value);
+        }
+        this._onDidChange.fire("options");
+        this._onDidChange.fire("disabled");
+        this.chatSessionsService.notifySessionOptionsChange(this.resource, [{
+            optionId,
+            value
+        }]).catch(
+            err => this.logService.error(`Failed to notify extension of ${optionId} change:`, err)
+        );
+    }
+    getModelOptionGroup() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return undefined;
+        }
+        const group = groups.find(g => isModelOptionGroup(g));
+        if (!group) {
+            return undefined;
+        }
+        return {
+            group,
+            value: this._getValueForGroup(group)
+        };
+    }
+    getOtherOptionGroups() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return [];
+        }
+        return ( groups.filter(
+            g => !isModelOptionGroup(g) && !isRepositoriesOptionGroup(g) && this._isOptionGroupVisible(g)
+        ).map(g => ({
+            group: g,
+            value: this._getValueForGroup(g)
+        })));
+    }
+    getOptionValue(groupId) {
+        return this.selectedOptions.get(groupId);
+    }
+    setOptionValue(groupId, value) {
+        this.setOption(groupId, value);
+    }
+    _getOptionGroups() {
+        return this.chatSessionsService.getOptionGroupsForSessionType(this.target);
+    }
+    _isOptionGroupVisible(group) {
+        if (!group.when) {
+            return true;
+        }
+        const expr = ContextKeyExpr.deserialize(group.when);
+        return !expr || this.contextKeyService.contextMatchesRules(expr);
+    }
+    _updateWhenClauseKeys() {
+        this._whenClauseKeys.clear();
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return;
+        }
+        for (const group of groups) {
+            if (group.when) {
+                const expr = ContextKeyExpr.deserialize(group.when);
+                if (expr) {
+                    for (const key of ( expr.keys())) {
+                        this._whenClauseKeys.add(key);
+                    }
+                }
+            }
+        }
+    }
+    _getValueForGroup(group) {
+        const selected = this.selectedOptions.get(group.id);
+        if (selected) {
+            return selected;
+        }
+        const sessionOption = this.chatSessionsService.getSessionOption(this.resource, group.id);
+        if (sessionOption && typeof sessionOption !== "string") {
+            return sessionOption;
+        }
+        if (typeof sessionOption === "string") {
+            const item = group.items.find(i => i.id === sessionOption.trim());
+            if (item) {
+                return item;
+            }
+        }
+        return group.items.find(i => i.default === true) ?? group.items[0];
+    }
+};
+RemoteNewSession = ( __decorate([( __param(2, IChatSessionsService)), ( __param(3, IContextKeyService)), ( __param(4, ILogService))], RemoteNewSession));
+function isModelOptionGroup(group) {
+    if (group.id === "models") {
+        return true;
+    }
+    const nameLower = group.name.toLowerCase();
+    return nameLower === "model" || nameLower === "models";
+}
+function isRepositoriesOptionGroup(group) {
+    return group.id === "repositories";
+}
+
+export { LocalNewSession, RemoteNewSession };

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.d.ts

@@ -0,0 +1,71 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IActiveSessionItem } from "../../sessions/browser/sessionsManagementService.js";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service";
+import { IJSONEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/jsonEditing.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { CommandString } from "@codingame/monaco-vscode-task-service-override/vscode/vs/workbench/contrib/tasks/common/taskConfiguration";
+import { ISessionsConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsConfigurationService.service";
+export type TaskStorageTarget = "user" | "workspace";
+/**
+ * Shape of a single task entry inside tasks.json.
+ */
+export interface ITaskEntry {
+    readonly label: string;
+    readonly task?: CommandString;
+    readonly script?: string;
+    readonly type?: string;
+    readonly command?: string;
+    readonly inSessions?: boolean;
+    readonly windows?: {
+        command?: string;
+    };
+    readonly osx?: {
+        command?: string;
+    };
+    readonly linux?: {
+        command?: string;
+    };
+    readonly [key: string]: unknown;
+}
+export declare class SessionsConfigurationService extends Disposable implements ISessionsConfigurationService {
+    private readonly _fileService;
+    private readonly _jsonEditingService;
+    private readonly _preferencesService;
+    private readonly _terminalService;
+    private readonly _sessionsManagementService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private static readonly _LAST_RUN_TASK_LABELS_KEY;
+    private static readonly _SUPPORTED_TASK_TYPES;
+    private readonly _sessionTasks;
+    private readonly _fileWatcher;
+    /** Maps `cwd.toString() + command` to the terminal `instanceId`. */
+    private readonly _taskTerminals;
+    private readonly _lastRunTaskLabels;
+    private readonly _lastRunTaskObservables;
+    private _watchedResource;
+    private _lastRefreshedFolder;
+    constructor(_fileService: IFileService, _jsonEditingService: IJSONEditingService, _preferencesService: IPreferencesService, _terminalService: ITerminalService, _sessionsManagementService: ISessionsManagementService, _storageService: IStorageService);
+    getSessionTasks(session: IActiveSessionItem): IObservable<readonly ITaskEntry[]>;
+    getNonSessionTasks(session: IActiveSessionItem): Promise<readonly ITaskEntry[]>;
+    addTaskToSessions(task: ITaskEntry, session: IActiveSessionItem, target: TaskStorageTarget): Promise<void>;
+    createAndAddTask(command: string, session: IActiveSessionItem, target: TaskStorageTarget): Promise<ITaskEntry | undefined>;
+    runTask(task: ITaskEntry, session: IActiveSessionItem): Promise<void>;
+    getLastRunTaskLabel(repository: URI | undefined): IObservable<string | undefined>;
+    private _getExistingTerminalInstance;
+    private _getTasksJsonUri;
+    private _readTasksJson;
+    private _readAllTasks;
+    private _isSupportedTask;
+    private _resolveCommand;
+    private _ensureFileWatch;
+    private _refreshSessionTasks;
+    private _commitTasksFile;
+    private _loadLastRunTaskLabels;
+    private _saveLastRunTaskLabels;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.js

@@ -0,0 +1,284 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonc';
+import { isWindows, isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { TerminalLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service';
+import { IJSONEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/jsonEditing.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var SessionsConfigurationService_1;
+let SessionsConfigurationService = class SessionsConfigurationService extends Disposable {
+    static {
+        SessionsConfigurationService_1 = this;
+    }
+    static {
+        this._LAST_RUN_TASK_LABELS_KEY = "agentSessions.lastRunTaskLabels";
+    }
+    static {
+        this._SUPPORTED_TASK_TYPES = ( new Set(["shell", "npm"]));
+    }
+    constructor(
+        _fileService,
+        _jsonEditingService,
+        _preferencesService,
+        _terminalService,
+        _sessionsManagementService,
+        _storageService
+    ) {
+        super();
+        this._fileService = _fileService;
+        this._jsonEditingService = _jsonEditingService;
+        this._preferencesService = _preferencesService;
+        this._terminalService = _terminalService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._storageService = _storageService;
+        this._sessionTasks = observableValue(this, []);
+        this._fileWatcher = this._register(( new MutableDisposable()));
+        this._taskTerminals = ( new Map());
+        this._lastRunTaskObservables = ( new Map());
+        this._lastRunTaskLabels = this._loadLastRunTaskLabels();
+    }
+    getSessionTasks(session) {
+        const folder = session.worktree ?? session.repository;
+        if (folder) {
+            this._ensureFileWatch(folder);
+        }
+        if (!isEqual(this._lastRefreshedFolder, folder)) {
+            this._lastRefreshedFolder = folder;
+            this._refreshSessionTasks(folder);
+        }
+        return this._sessionTasks;
+    }
+    async getNonSessionTasks(session) {
+        const allTasks = await this._readAllTasks(session);
+        return allTasks.filter(t => !t.inSessions);
+    }
+    async addTaskToSessions(task, session, target) {
+        const tasksJsonUri = this._getTasksJsonUri(session, target);
+        if (!tasksJsonUri) {
+            return;
+        }
+        const tasksJson = await this._readTasksJson(tasksJsonUri);
+        const tasks = tasksJson.tasks ?? [];
+        const index = tasks.findIndex(t => t.label === task.label);
+        if (index === -1) {
+            return;
+        }
+        await this._jsonEditingService.write(tasksJsonUri, [{
+            path: ["tasks", index, "inSessions"],
+            value: true
+        }], true);
+        if (target === "workspace") {
+            await this._commitTasksFile(session);
+        }
+    }
+    async createAndAddTask(command, session, target) {
+        const tasksJsonUri = this._getTasksJsonUri(session, target);
+        if (!tasksJsonUri) {
+            return undefined;
+        }
+        const tasksJson = await this._readTasksJson(tasksJsonUri);
+        const tasks = tasksJson.tasks ?? [];
+        const newTask = {
+            label: command,
+            type: "shell",
+            command,
+            inSessions: true
+        };
+        await this._jsonEditingService.write(tasksJsonUri, [{
+            path: ["version"],
+            value: tasksJson.version ?? "2.0.0"
+        }, {
+            path: ["tasks"],
+            value: [...tasks, newTask]
+        }], true);
+        if (target === "workspace") {
+            await this._commitTasksFile(session);
+        }
+        return newTask;
+    }
+    async runTask(task, session) {
+        const command = this._resolveCommand(task);
+        if (!command) {
+            return;
+        }
+        const cwd = session.worktree ?? session.repository;
+        if (!cwd) {
+            return;
+        }
+        const terminalKey = `${( cwd.toString())}${command}`;
+        let terminal = this._getExistingTerminalInstance(terminalKey);
+        if (!terminal) {
+            terminal = await this._terminalService.createTerminal({
+                location: TerminalLocation.Panel,
+                config: {
+                    name: task.label
+                },
+                cwd
+            });
+            this._taskTerminals.set(terminalKey, terminal.instanceId);
+        }
+        await terminal.sendText(command, true);
+        this._terminalService.setActiveInstance(terminal);
+        await this._terminalService.revealActiveTerminal();
+        if (session.repository) {
+            const key = ( session.repository.toString());
+            this._lastRunTaskLabels.set(key, task.label);
+            this._saveLastRunTaskLabels();
+            const obs = this._lastRunTaskObservables.get(key);
+            if (obs) {
+                transaction(tx => obs.set(task.label, tx));
+            }
+        }
+    }
+    getLastRunTaskLabel(repository) {
+        if (!repository) {
+            return observableValue("lastRunTaskLabel", undefined);
+        }
+        const key = ( repository.toString());
+        let obs = this._lastRunTaskObservables.get(key);
+        if (!obs) {
+            obs = observableValue("lastRunTaskLabel", this._lastRunTaskLabels.get(key));
+            this._lastRunTaskObservables.set(key, obs);
+        }
+        return obs;
+    }
+    _getExistingTerminalInstance(terminalKey) {
+        const instanceId = this._taskTerminals.get(terminalKey);
+        if (instanceId === undefined) {
+            return undefined;
+        }
+        const instance = this._terminalService.instances.find(i => i.instanceId === instanceId);
+        if (!instance || instance.hasChildProcesses) {
+            this._taskTerminals.delete(terminalKey);
+            return undefined;
+        }
+        return instance;
+    }
+    _getTasksJsonUri(session, target) {
+        if (target === "workspace") {
+            const folder = session.worktree ?? session.repository;
+            return folder ? joinPath(folder, ".vscode", "tasks.json") : undefined;
+        }
+        return joinPath(dirname(this._preferencesService.userSettingsResource), "tasks.json");
+    }
+    async _readTasksJson(uri) {
+        try {
+            const content = await this._fileService.readFile(uri);
+            return parse(( content.value.toString()));
+        } catch {
+            return {};
+        }
+    }
+    async _readAllTasks(session) {
+        const result = [];
+        const workspaceUri = this._getTasksJsonUri(session, "workspace");
+        if (workspaceUri) {
+            const workspaceJson = await this._readTasksJson(workspaceUri);
+            if (workspaceJson.tasks) {
+                result.push(...workspaceJson.tasks.filter(t => this._isSupportedTask(t)));
+            }
+        }
+        const userUri = this._getTasksJsonUri(session, "user");
+        if (userUri) {
+            const userJson = await this._readTasksJson(userUri);
+            if (userJson.tasks) {
+                result.push(...userJson.tasks.filter(t => this._isSupportedTask(t)));
+            }
+        }
+        return result;
+    }
+    _isSupportedTask(task) {
+        return !!task.type && ( SessionsConfigurationService_1._SUPPORTED_TASK_TYPES.has(task.type));
+    }
+    _resolveCommand(task) {
+        if (task.type === "npm") {
+            if (!task.script) {
+                return undefined;
+            }
+            if (task.path) {
+                return `npm --prefix ${task.path} run ${task.script}`;
+            }
+            return `npm run ${task.script}`;
+        }
+        if (isWindows && task.windows?.command) {
+            return task.windows.command;
+        }
+        if (isMacintosh && task.osx?.command) {
+            return task.osx.command;
+        }
+        if (!isWindows && !isMacintosh && task.linux?.command) {
+            return task.linux.command;
+        }
+        return task.command;
+    }
+    _ensureFileWatch(folder) {
+        const tasksUri = joinPath(folder, ".vscode", "tasks.json");
+        if (this._watchedResource && ( this._watchedResource.toString()) === ( tasksUri.toString())) {
+            return;
+        }
+        this._watchedResource = tasksUri;
+        const disposables = ( new DisposableStore());
+        disposables.add(this._fileService.watch(tasksUri));
+        disposables.add(this._fileService.onDidFilesChange(e => {
+            if (e.affects(tasksUri)) {
+                this._refreshSessionTasks(folder);
+            }
+        }));
+        this._fileWatcher.value = disposables;
+    }
+    async _refreshSessionTasks(folder) {
+        if (!folder) {
+            transaction(tx => this._sessionTasks.set([], tx));
+            return;
+        }
+        const tasksUri = joinPath(folder, ".vscode", "tasks.json");
+        const tasksJson = await this._readTasksJson(tasksUri);
+        const sessionTasks = (tasksJson.tasks ?? []).filter(t => t.inSessions && this._isSupportedTask(t));
+        const userUri = joinPath(dirname(this._preferencesService.userSettingsResource), "tasks.json");
+        const userJson = await this._readTasksJson(userUri);
+        const userSessionTasks = (userJson.tasks ?? []).filter(t => t.inSessions && this._isSupportedTask(t));
+        transaction(tx => this._sessionTasks.set([...sessionTasks, ...userSessionTasks], tx));
+    }
+    async _commitTasksFile(session) {
+        const worktree = session.worktree;
+        if (!worktree) {
+            return;
+        }
+        const tasksUri = joinPath(worktree, ".vscode", "tasks.json");
+        await this._sessionsManagementService.commitWorktreeFiles(session, [tasksUri]);
+    }
+    _loadLastRunTaskLabels() {
+        const raw = this._storageService.get(
+            SessionsConfigurationService_1._LAST_RUN_TASK_LABELS_KEY,
+            StorageScope.APPLICATION
+        );
+        if (raw) {
+            try {
+                return ( new Map(Object.entries(JSON.parse(raw))));
+            } catch {}
+        }
+        return ( new Map());
+    }
+    _saveLastRunTaskLabels() {
+        this._storageService.store(
+            SessionsConfigurationService_1._LAST_RUN_TASK_LABELS_KEY,
+            JSON.stringify(Object.fromEntries(this._lastRunTaskLabels)),
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
+    }
+};
+SessionsConfigurationService = SessionsConfigurationService_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IJSONEditingService)), ( __param(2, IPreferencesService)), ( __param(3, ITerminalService)), ( __param(4, ISessionsManagementService)), ( __param(5, IStorageService))], SessionsConfigurationService));
+
+export { SessionsConfigurationService };