@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/devContainerAgentHostService.js

@@ -0,0 +1,496 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { raceCancellationError, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { agentsWindowAgentHostClientInfo } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostClientInfo';
+import { AgentHostProtocolClient } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/browser/agentHostProtocolClient';
+import { RemoteAgentHostEntryType, getEntryTypeConfig, RemoteAgentHostConnectionStatus, getEntryAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+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 { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY = "devContainerAgentHost.connections";
+const CONNECTOR_REGISTRATION_TIMEOUT_MS = 30_000;
+function isStoredDevContainerAgentHost(value) {
+    return typeof value === "object" && value !== null && typeof Reflect.get(value, "workspaceUri") === "string" && typeof Reflect.get(value, "name") === "string";
+}
+function devContainerAddress(workspaceUri) {
+    const sha = ( new StringSHA1());
+    sha.update(getComparisonKey(workspaceUri));
+    return `devcontainer:${sha.digest()}`;
+}
+class DevContainerConnectionFactory extends Disposable {
+    constructor(_instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this.kind = RemoteAgentHostEntryType.DevContainer;
+        this._stagedConnections = ( new Map());
+        this._entries = observableValue(this, []);
+        this.entries = this._entries;
+    }
+    stageConnection(connector, workspaceUri, connection) {
+        const entry = {
+            name: connection.name,
+            connection: {
+                type: RemoteAgentHostEntryType.DevContainer,
+                address: connection.address,
+                hostPath: workspaceUri.fsPath
+            }
+        };
+        this._stagedConnections.set(connection.address, {
+            entry,
+            connector,
+            workspaceUri,
+            initialConnection: connection
+        });
+        this._updateEntries();
+        return entry;
+    }
+    unstageConnection(address) {
+        const staged = this._stagedConnections.get(address);
+        this._stagedConnections.delete(address);
+        staged?.initialConnection?.transportDisposable?.dispose();
+        this._updateEntries();
+    }
+    async createConnection(entry, _options) {
+        if (entry.connection.type !== RemoteAgentHostEntryType.DevContainer) {
+            throw ( new Error(
+                `Dev Container factory cannot create a ${entry.connection.type} connection.`
+            ));
+        }
+        const staged = this._stagedConnections.get(entry.connection.address);
+        if (!staged) {
+            throw ( new Error(`No Dev Container connection is staged for ${entry.connection.address}.`));
+        }
+        const connection = staged.initialConnection ?? (await staged.connector.createConnection(staged.workspaceUri, entry.connection.address, CancellationToken.None));
+        try {
+            const authority = agentHostAuthority(entry.connection.address);
+            if (connection.workspaceUri.scheme !== AGENT_HOST_SCHEME || connection.workspaceUri.authority !== authority) {
+                throw ( new Error(( localize(
+                    4266,
+                    "Dev Container workspace URI must use the '{0}' scheme and '{1}' authority.",
+                    AGENT_HOST_SCHEME,
+                    authority
+                ))));
+            }
+            const client = this._instantiationService.createInstance(
+                AgentHostProtocolClient,
+                entry.connection.address,
+                connection.transportFactory,
+                {
+                    clientInfo: agentsWindowAgentHostClientInfo,
+                    reconnectPolicy: getEntryTypeConfig(RemoteAgentHostEntryType.DevContainer).reconnect
+                }
+            );
+            staged.initialConnection = undefined;
+            return {
+                connection: client,
+                transportDisposable: connection.transportDisposable
+            };
+        } catch (error) {
+            if (staged.initialConnection === connection) {
+                staged.initialConnection = undefined;
+            }
+            connection.transportDisposable?.dispose();
+            throw error;
+        }
+    }
+    _updateEntries() {
+        this._entries.set([...( this._stagedConnections.values())].map(connection => connection.entry), undefined);
+    }
+}
+let DevContainerAgentHostService = class DevContainerAgentHostService extends Disposable {
+    constructor(
+        _instantiationService,
+        _remoteAgentHostService,
+        _sessionsProvidersService,
+        _storageService
+    ) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._storageService = _storageService;
+        this._providerStores = this._register(( new DisposableMap()));
+        this._providers = ( new Map());
+        this._activeConnections = ( new Map());
+        this._pendingConnections = ( new Map());
+        this._storedConnections = ( new Map());
+        this._onDidRegisterConnector = this._register(( new Emitter()));
+        this._onDidChangeAvailability = this._register(( new Emitter()));
+        this.onDidChangeAvailability = this._onDidChangeAvailability.event;
+        this._connectionFactory = this._register(( new DevContainerConnectionFactory(this._instantiationService)));
+        this._register(
+            this._remoteAgentHostService.registerConnectionFactory(this._connectionFactory)
+        );
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._reconcileConnections())
+        );
+        this._restoreProviders();
+        this._register(this._storageService.onDidChangeValue(
+            StorageScope.APPLICATION,
+            DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY,
+            this._store
+        )(() => this._restoreProviders()));
+    }
+    registerConnector(connector) {
+        if (this._connector) {
+            throw ( new Error(( localize(4267, "A Dev Container Agent Host connector is already registered."))));
+        }
+        this._connector = connector;
+        this._onDidRegisterConnector.fire(connector);
+        this._onDidChangeAvailability.fire();
+        return toDisposable(() => {
+            if (this._connector === connector) {
+                this._connector = undefined;
+                this._onDidChangeAvailability.fire();
+            }
+        });
+    }
+    isAvailable(workspaceUri) {
+        return this._connector?.isAvailable(workspaceUri) ?? Promise.resolve(false);
+    }
+    connect(workspaceUri, token) {
+        return this._ensureConnection(workspaceUri, token).then(active => this._acquireConnection(getComparisonKey(workspaceUri), active));
+    }
+    _ensureConnection(workspaceUri, token) {
+        const key = getComparisonKey(workspaceUri);
+        const active = this._activeConnections.get(key);
+        if (active && this._isConnectedOrReconnecting(active.address)) {
+            return Promise.resolve(active);
+        }
+        const pending = this._pendingConnections.get(key);
+        if (pending) {
+            return raceCancellationError(pending.promise, token);
+        }
+        this._providers.get(key)?.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
+        const tokenSource = ( new CancellationTokenSource(token));
+        const promise = this._replaceConnectionAndConnect(workspaceUri, key, active, tokenSource.token);
+        const pendingConnection = {
+            promise,
+            tokenSource
+        };
+        this._pendingConnections.set(key, pendingConnection);
+        void promise.then(
+            () => this._completePendingConnection(key, pendingConnection),
+            () => this._completePendingConnection(key, pendingConnection)
+        );
+        return promise;
+    }
+    _completePendingConnection(key, pending) {
+        if (this._pendingConnections.get(key) === pending) {
+            this._pendingConnections.delete(key);
+        }
+        if (!( this._activeConnections.has(key))) {
+            this._providers.get(key)?.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+        }
+        pending.tokenSource.dispose();
+    }
+    async _replaceConnectionAndConnect(workspaceUri, key, active, token) {
+        const connector = this._connector ?? (await this._waitForConnector(token));
+        if (active) {
+            await this._disconnectActiveConnection(key, active);
+        }
+        return this._connect(connector, workspaceUri, key, token);
+    }
+    async _waitForConnector(token) {
+        const connectorPromise = Event.toPromise(this._onDidRegisterConnector.event);
+        try {
+            const connector = await raceCancellationError(raceTimeout(connectorPromise, CONNECTOR_REGISTRATION_TIMEOUT_MS), token);
+            if (!connector) {
+                throw ( new Error(( localize(4268, "No Dev Container Agent Host connector is registered."))));
+            }
+            return connector;
+        } finally {
+            connectorPromise.cancel();
+        }
+    }
+    async _connect(connector, workspaceUri, key, token) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        const connected = await connector.createConnection(workspaceUri, devContainerAddress(workspaceUri), token);
+        if (token.isCancellationRequested) {
+            connected.transportDisposable?.dispose();
+            throw ( new CancellationError());
+        }
+        let stagedAddress;
+        try {
+            const provider = this._ensureProvider(workspaceUri, connected.name, connected.address);
+            const entry = this._connectionFactory.stageConnection(connector, workspaceUri, connected);
+            const address = getEntryAddress(entry);
+            stagedAddress = address;
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            this._remoteAgentHostService.reconnect(address, true);
+            const connectionInfo = await raceCancellationError(this._remoteAgentHostService.waitForConnection(address), token);
+            const connection = this._remoteAgentHostService.getConnection(connectionInfo.address);
+            if (!connection) {
+                throw ( new Error(( localize(
+                    4269,
+                    "Dev Container Agent Host connection was not available after connecting."
+                ))));
+            }
+            provider.setConnection(connection, connected.defaultDirectory ?? connectionInfo.defaultDirectory);
+            provider.setConnectionStatus(connectionInfo.status);
+            await this._waitForSessionTypes(provider, token);
+            if (provider.getSessions().length > 0) {
+                this._storeConnection(workspaceUri, connected.name);
+            }
+            const target = {
+                providerId: provider.id,
+                workspaceUri: connected.workspaceUri
+            };
+            const active = {
+                address,
+                provider,
+                target,
+                references: 0
+            };
+            this._activeConnections.set(key, active);
+            return active;
+        } catch (error) {
+            if (stagedAddress !== undefined) {
+                const connectionStillLive = this._isConnectedOrReconnecting(stagedAddress);
+                if (token.isCancellationRequested || !connectionStillLive) {
+                    this._connectionFactory.unstageConnection(stagedAddress);
+                    await this._remoteAgentHostService.removeRemoteAgentHost(stagedAddress);
+                }
+            } else {
+                connected.transportDisposable?.dispose();
+            }
+            if (!( this._storedConnections.has(key))) {
+                this._removeProvider(key);
+            }
+            throw error;
+        }
+    }
+    _acquireConnection(key, active) {
+        active.references++;
+        let released = false;
+        return {
+            ...active.target,
+            release: async () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                active.references--;
+                if (active.references === 0 && this._activeConnections.get(key) === active) {
+                    await this._disconnectActiveConnection(key, active);
+                    if (active.provider.getSessions().length === 0) {
+                        this._removeStoredConnection(key);
+                        this._removeProvider(key);
+                    }
+                }
+            }
+        };
+    }
+    _ensureProvider(workspaceUri, name, address = devContainerAddress(workspaceUri)) {
+        const key = getComparisonKey(workspaceUri);
+        const existing = this._providers.get(key);
+        if (existing) {
+            return existing;
+        }
+        const store = ( new DisposableStore());
+        const provider = store.add(this._createProvider({
+            address,
+            name,
+            devContainerWorktreeScope: key,
+            omitHostFromWorkspaceLabel: true,
+            connectOnDemand: async () => {
+                await this._ensureConnection(workspaceUri, CancellationToken.None);
+            },
+            disconnectOnDemand: () => this.disconnect(workspaceUri)
+        }));
+        provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+        store.add(this._sessionsProvidersService.registerProvider(provider));
+        store.add(provider.onDidChangeSessions(event => {
+            if (event.added.length > 0) {
+                this._storeConnection(workspaceUri, name);
+            }
+        }));
+        store.add(toDisposable(() => this._providers.delete(key)));
+        this._providers.set(key, provider);
+        this._providerStores.set(key, store);
+        return provider;
+    }
+    _createProvider(config) {
+        return this._instantiationService.createInstance(RemoteAgentHostSessionsProvider, config);
+    }
+    async _waitForSessionTypes(provider, token) {
+        const deadline = Date.now() + 30_000;
+        while (provider.sessionTypes.length === 0) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw ( new Error(( localize(
+                    4270,
+                    "Timed out waiting for the Dev Container Agent Host to advertise agents."
+                ))));
+            }
+            let timedOut = false;
+            await raceCancellationError(raceTimeout(
+                Event.toPromise(provider.onDidChangeSessionTypes),
+                remaining,
+                () => timedOut = true
+            ), token);
+            if (timedOut) {
+                throw ( new Error(( localize(
+                    4270,
+                    "Timed out waiting for the Dev Container Agent Host to advertise agents."
+                ))));
+            }
+        }
+    }
+    async disconnect(workspaceUri) {
+        const key = getComparisonKey(workspaceUri);
+        const pending = this._pendingConnections.get(key);
+        if (pending) {
+            pending.tokenSource.cancel();
+            await pending.promise.then(() => undefined, () => undefined);
+        }
+        const active = this._activeConnections.get(key);
+        if (!active) {
+            return;
+        }
+        await this._disconnectActiveConnection(key, active);
+        if (active.provider.getSessions().length === 0) {
+            this._removeStoredConnection(key);
+            this._removeProvider(key);
+        }
+    }
+    async _disconnectActiveConnection(key, active) {
+        this._activeConnections.delete(key);
+        this._connectionFactory.unstageConnection(active.address);
+        await this._remoteAgentHostService.removeRemoteAgentHost(active.address);
+        active.provider.clearConnection();
+        active.provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+    }
+    _isConnectedOrReconnecting(address) {
+        return ( this._remoteAgentHostService.connections.some(
+            connection => connection.address === address && (RemoteAgentHostConnectionStatus.isConnected(connection.status) || RemoteAgentHostConnectionStatus.isReconnecting(connection.status))
+        ));
+    }
+    _reconcileConnections() {
+        for (const [key, active] of this._activeConnections) {
+            const connectionInfo = this._remoteAgentHostService.connections.find(connection => connection.address === active.address);
+            if (!connectionInfo) {
+                this._activeConnections.delete(key);
+                this._connectionFactory.unstageConnection(active.address);
+                active.provider.clearConnection();
+                active.provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+                if (!( this._storedConnections.has(key))) {
+                    this._removeProvider(key);
+                }
+                continue;
+            }
+            active.provider.setConnectionStatus(connectionInfo.status);
+            if (RemoteAgentHostConnectionStatus.isConnected(connectionInfo.status)) {
+                const connection = this._remoteAgentHostService.getConnection(active.address);
+                if (connection) {
+                    active.provider.setConnection(connection, connectionInfo.defaultDirectory);
+                }
+            }
+        }
+    }
+    _restoreProviders() {
+        const stored = this._readStoredConnections();
+        for (const key of ( this._storedConnections.keys())) {
+            if (!( stored.has(key))) {
+                this._storedConnections.delete(key);
+                if (!( this._activeConnections.has(key))) {
+                    this._removeProvider(key);
+                }
+            }
+        }
+        for (const [key, connection] of stored) {
+            this._storedConnections.set(key, connection);
+            const workspaceUri = ( URI.parse(connection.workspaceUri));
+            this._ensureProvider(workspaceUri, connection.name);
+        }
+    }
+    _readStoredConnections() {
+        const result = ( new Map());
+        const raw = this._storageService.get(DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!raw) {
+            return result;
+        }
+        try {
+            const stored = JSON.parse(raw);
+            if (!Array.isArray(stored)) {
+                return result;
+            }
+            for (const candidate of stored) {
+                if (!isStoredDevContainerAgentHost(candidate)) {
+                    continue;
+                }
+                const uri = ( URI.parse(candidate.workspaceUri));
+                if (uri.scheme !== Schemas.file || candidate.name.length === 0) {
+                    continue;
+                }
+                result.set(getComparisonKey(uri), {
+                    workspaceUri: ( uri.toString()),
+                    name: candidate.name
+                });
+            }
+        } catch {
+            return result;
+        }
+        return result;
+    }
+    _storeConnection(workspaceUri, name) {
+        const key = getComparisonKey(workspaceUri);
+        const stored = {
+            workspaceUri: ( workspaceUri.toString()),
+            name
+        };
+        const existing = this._storedConnections.get(key);
+        if (existing?.workspaceUri === stored.workspaceUri && existing.name === stored.name) {
+            return;
+        }
+        this._storedConnections.set(key, stored);
+        this._writeStoredConnections();
+    }
+    _removeStoredConnection(key) {
+        if (this._storedConnections.delete(key)) {
+            this._writeStoredConnections();
+        }
+    }
+    _writeStoredConnections() {
+        if (this._storedConnections.size === 0) {
+            this._storageService.remove(DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        this._storageService.store(DEV_CONTAINER_AGENT_HOSTS_STORAGE_KEY, JSON.stringify([...( this._storedConnections.values())]), StorageScope.APPLICATION, StorageTarget.MACHINE);
+    }
+    _removeProvider(key) {
+        this._providerStores.deleteAndDispose(key);
+    }
+    dispose() {
+        for (const pending of ( this._pendingConnections.values())) {
+            pending.tokenSource.cancel();
+            pending.tokenSource.dispose();
+        }
+        this._pendingConnections.clear();
+        super.dispose();
+    }
+};
+DevContainerAgentHostService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IStorageService))], DevContainerAgentHostService));
+
+export { DevContainerAgentHostService };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.d.ts

@@ -0,0 +1,27 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostAuthenticateRequest } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostAuth";
+import { IRemoteAgentHostConnectionCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.service";
+/**
+ * Per-connection behavior a specific remote-agent-host kind can inject into the otherwise
+ * host-agnostic remote-agent-host contribution. Connections with no customization are unaffected.
+ */
+export interface IRemoteAgentHostConnectionCustomization {
+    /**
+     * Transform the outgoing `authenticate` request before it is sent. Must fail closed: throw rather
+     * than forward a value that does not meet the host's contract. Omit to forward it unchanged.
+     */
+    readonly authenticate?: (request: IAgentHostAuthenticateRequest) => Promise<IAgentHostAuthenticateRequest>;
+    /**
+     * The backend session URI scheme for an agent provider when it differs from the provider itself.
+     * Return `undefined` to keep scheme == provider.
+     */
+    readonly backendSessionScheme?: (provider: string) => string | undefined;
+}
+/** Builds a {@link IRemoteAgentHostConnectionCustomization} for a concrete connection address. */
+export type RemoteAgentHostConnectionCustomizationFactory = (address: string) => IRemoteAgentHostConnectionCustomization;
+export declare class RemoteAgentHostConnectionCustomizationService implements IRemoteAgentHostConnectionCustomizationService {
+    readonly _serviceBrand: undefined;
+    private readonly _entries;
+    register(match: (address: string) => boolean, factory: RemoteAgentHostConnectionCustomizationFactory): IDisposable;
+    get(address: string): IRemoteAgentHostConnectionCustomization | undefined;
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.js

@@ -0,0 +1,26 @@
+
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+class RemoteAgentHostConnectionCustomizationService {
+    constructor() {
+        this._entries = ( new Set());
+    }
+    register(match, factory) {
+        const entry = {
+            match,
+            factory
+        };
+        this._entries.add(entry);
+        return toDisposable(() => this._entries.delete(entry));
+    }
+    get(address) {
+        for (const entry of this._entries) {
+            if (entry.match(address)) {
+                return entry.factory(address);
+            }
+        }
+        return undefined;
+    }
+}
+
+export { RemoteAgentHostConnectionCustomizationService };

package/vscode/src/vs/sessions/contrib/search/browser/media/searchEditorEmptyState.css

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.sessions-search-empty-state {
+	top: 0;
+	left: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	box-sizing: border-box;
+	padding: var(--vscode-spacing-size200);
+	pointer-events: none;
+}

package/vscode/src/vs/sessions/contrib/search/browser/search.contribution.d.ts

@@ -0,0 +1 @@
+

package/vscode/src/vs/sessions/contrib/search/browser/search.contribution.js

@@ -0,0 +1,79 @@
+
+import './searchEditorEmptyState.contribution.js';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuRegistry, MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { IExplorerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/files.service';
+import { OpenEditorCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/searchEditor/browser/constants';
+import { resolveResourcesForSearchIncludes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/queryBuilder';
+import { SESSIONS_FILES_VIEW_ID } from '../../files/browser/filesView.js';
+
+KeybindingsRegistry.registerKeybindingRule({
+    id: OpenEditorCommandId,
+    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyF,
+    weight: KeybindingWeight.WorkbenchContrib
+});
+MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+    command: {
+        id: OpenEditorCommandId,
+        title: ( localize2(4462, "Search")),
+        icon: Codicon.search
+    },
+    group: "1_files",
+    order: 0,
+    when: ( ContextKeyExpr.equals("view", SESSIONS_FILES_VIEW_ID))
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+    command: {
+        id: OpenEditorCommandId,
+        title: ( localize(4463, "&&Search"))
+    },
+    group: "4_auxbar",
+    order: 1
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.files.action.findInFolder",
+            title: ( localize2(4464, "Find in Folder...")),
+            menu: {
+                id: MenuId.ExplorerContext,
+                group: "4_search",
+                order: 10,
+                when: ExplorerFolderContext
+            }
+        });
+    }
+    async run(accessor, resource) {
+        const explorerService = accessor.get(IExplorerService);
+        const fileService = accessor.get(IFileService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const commandService = accessor.get(ICommandService);
+        const resources = resource ? [resource] : explorerService.getContext(true).map(item => item.resource);
+        const results = await fileService.resolveAll(resources.map(resource => ({
+            resource
+        })));
+        const folders = [];
+        for (const result of results) {
+            if (result.success && result.stat) {
+                folders.push(
+                    result.stat.isDirectory ? result.stat.resource : dirname(result.stat.resource)
+                );
+            }
+        }
+        const filesToInclude = resolveResourcesForSearchIncludes(folders, contextService);
+        await commandService.executeCommand(OpenEditorCommandId, {
+            filesToInclude: filesToInclude.join(", "),
+            showIncludesExcludes: true,
+            location: "reuse"
+        });
+    }
+});

package/vscode/src/vs/sessions/contrib/search/browser/searchEditorEmptyState.contribution.d.ts

@@ -0,0 +1,7 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IEditorContribution } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
+export declare class SearchEditorEmptyStateContribution extends Disposable implements IEditorContribution {
+    static readonly ID = "sessions.searchEditor.emptyState";
+    constructor(editor: ICodeEditor);
+}