@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteExplorer.js

@@ -0,0 +1,186 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { OnPortForward, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
+import { OpenPortInPreviewAction, OpenPortInBrowserAction, TunnelPanel, openPreviewEnabledContext } from './tunnelView.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+const VIEWLET_ID = 'workbench.view.remote';
+class OnAutoForwardedAction extends Disposable {
+    constructor(notificationService, remoteExplorerService, openerService, externalOpenerService, tunnelService, hostService, logService, contextKeyService) {
+        super();
+        this.notificationService = notificationService;
+        this.remoteExplorerService = remoteExplorerService;
+        this.openerService = openerService;
+        this.externalOpenerService = externalOpenerService;
+        this.tunnelService = tunnelService;
+        this.hostService = hostService;
+        this.logService = logService;
+        this.contextKeyService = contextKeyService;
+        this.alreadyOpenedOnce = ( new Set());
+        this.lastNotifyTime = ( new Date());
+        this.lastNotifyTime.setFullYear(this.lastNotifyTime.getFullYear() - 1);
+    }
+    async doAction(tunnels) {
+        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Starting action for ${tunnels[0]?.tunnelRemotePort}`);
+        this.doActionTunnels = tunnels;
+        const tunnel = await this.portNumberHeuristicDelay();
+        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose ${tunnel?.tunnelRemotePort}`);
+        if (tunnel) {
+            const allAttributes = await this.remoteExplorerService.tunnelModel.getAttributes([{ port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost }]);
+            const attributes = allAttributes?.get(tunnel.tunnelRemotePort)?.onAutoForward;
+            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) onAutoForward action is ${attributes}`);
+            switch (attributes) {
+                case OnPortForward.OpenBrowserOnce: {
+                    if (( this.alreadyOpenedOnce.has(tunnel.localAddress))) {
+                        break;
+                    }
+                    this.alreadyOpenedOnce.add(tunnel.localAddress);
+                }
+                case OnPortForward.OpenBrowser: {
+                    const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                    await OpenPortInBrowserAction.run(this.remoteExplorerService.tunnelModel, this.openerService, address);
+                    break;
+                }
+                case OnPortForward.OpenPreview: {
+                    const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                    await OpenPortInPreviewAction.run(this.remoteExplorerService.tunnelModel, this.openerService, this.externalOpenerService, address);
+                    break;
+                }
+                case OnPortForward.Silent: break;
+                default: {
+                    const elapsed = ( new Date()).getTime() - this.lastNotifyTime.getTime();
+                    this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) time elapsed since last notification ${elapsed} ms`);
+                    if (elapsed > OnAutoForwardedAction.NOTIFY_COOL_DOWN) {
+                        await this.showNotification(tunnel);
+                    }
+                }
+            }
+        }
+    }
+    hide(removedPorts) {
+        if (this.doActionTunnels) {
+            this.doActionTunnels = this.doActionTunnels.filter(value => !removedPorts.includes(value.tunnelRemotePort));
+        }
+        if (this.lastShownPort && removedPorts.indexOf(this.lastShownPort) >= 0) {
+            this.lastNotification?.close();
+        }
+    }
+    async portNumberHeuristicDelay() {
+        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Starting heuristic delay`);
+        if (!this.doActionTunnels || this.doActionTunnels.length === 0) {
+            return;
+        }
+        this.doActionTunnels = this.doActionTunnels.sort((a, b) => a.tunnelRemotePort - b.tunnelRemotePort);
+        const firstTunnel = this.doActionTunnels.shift();
+        if (firstTunnel.tunnelRemotePort % 1000 === 0) {
+            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose tunnel because % 1000: ${firstTunnel.tunnelRemotePort}`);
+            this.newerTunnel = firstTunnel;
+            return firstTunnel;
+        }
+        else if (firstTunnel.tunnelRemotePort < 10000 && firstTunnel.tunnelRemotePort !== 9229) {
+            this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Heuristic chose tunnel because < 10000: ${firstTunnel.tunnelRemotePort}`);
+            this.newerTunnel = firstTunnel;
+            return firstTunnel;
+        }
+        this.logService.trace(`ForwardedPorts: (OnAutoForwardedAction) Waiting for "better" tunnel than ${firstTunnel.tunnelRemotePort}`);
+        this.newerTunnel = undefined;
+        return ( new Promise(resolve => {
+            setTimeout(() => {
+                if (this.newerTunnel) {
+                    resolve(undefined);
+                }
+                else if (this.doActionTunnels?.includes(firstTunnel)) {
+                    resolve(firstTunnel);
+                }
+                else {
+                    resolve(undefined);
+                }
+            }, 3000);
+        }));
+    }
+    basicMessage(tunnel) {
+        return ( nls.localize(
+            'remote.tunnelsView.automaticForward',
+            "Your application running on port {0} is available.  ",
+            tunnel.tunnelRemotePort
+        ));
+    }
+    linkMessage() {
+        return ( nls.localize(
+            { key: 'remote.tunnelsView.notificationLink2', comment: ['[See all forwarded ports]({0}) is a link. Only translate `See all forwarded ports`. Do not change brackets and parentheses or {0}'] },
+            "[See all forwarded ports]({0})",
+            `command:${TunnelPanel.ID}.focus`
+        ));
+    }
+    async showNotification(tunnel) {
+        if (!(await this.hostService.hadLastFocus())) {
+            return;
+        }
+        this.lastNotification?.close();
+        let message = this.basicMessage(tunnel);
+        const choices = [this.openBrowserChoice(tunnel)];
+        if (!isWeb || openPreviewEnabledContext.getValue(this.contextKeyService)) {
+            choices.push(this.openPreviewChoice(tunnel));
+        }
+        if ((tunnel.tunnelLocalPort !== tunnel.tunnelRemotePort) && this.tunnelService.canElevate && this.tunnelService.isPortPrivileged(tunnel.tunnelRemotePort)) {
+            message += ( nls.localize(
+                'remote.tunnelsView.elevationMessage',
+                "You'll need to run as superuser to use port {0} locally.  ",
+                tunnel.tunnelRemotePort
+            ));
+            choices.unshift(this.elevateChoice(tunnel));
+        }
+        message += this.linkMessage();
+        this.lastNotification = this.notificationService.prompt(Severity.Info, message, choices, { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
+        this.lastShownPort = tunnel.tunnelRemotePort;
+        this.lastNotifyTime = ( new Date());
+        this.lastNotification.onDidClose(() => {
+            this.lastNotification = undefined;
+            this.lastShownPort = undefined;
+        });
+    }
+    openBrowserChoice(tunnel) {
+        const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+        return {
+            label: OpenPortInBrowserAction.LABEL,
+            run: () => OpenPortInBrowserAction.run(this.remoteExplorerService.tunnelModel, this.openerService, address)
+        };
+    }
+    openPreviewChoice(tunnel) {
+        const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+        return {
+            label: OpenPortInPreviewAction.LABEL,
+            run: () => OpenPortInPreviewAction.run(this.remoteExplorerService.tunnelModel, this.openerService, this.externalOpenerService, address)
+        };
+    }
+    elevateChoice(tunnel) {
+        return {
+            label: ( nls.localize(
+                'remote.tunnelsView.elevationButton',
+                "Use Port {0} as Sudo...",
+                tunnel.tunnelRemotePort
+            )),
+            run: async () => {
+                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort });
+                const newTunnel = await this.remoteExplorerService.forward({
+                    remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
+                    local: tunnel.tunnelRemotePort,
+                    elevateIfNeeded: true,
+                    source: AutoTunnelSource
+                });
+                if (!newTunnel) {
+                    return;
+                }
+                this.lastNotification?.close();
+                this.lastShownPort = newTunnel.tunnelRemotePort;
+                this.lastNotification = this.notificationService.prompt(Severity.Info, this.basicMessage(newTunnel) + this.linkMessage(), [this.openBrowserChoice(newTunnel), this.openPreviewChoice(tunnel)], { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
+                this.lastNotification.onDidClose(() => {
+                    this.lastNotification = undefined;
+                    this.lastShownPort = undefined;
+                });
+            }
+        };
+    }
+}
+OnAutoForwardedAction.NOTIFY_COOL_DOWN = 5000;
+export { VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteIcons.js

@@ -0,0 +1,23 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const privatePortIcon = ( registerIcon('private-ports-view-icon', Codicon.lock, ( nls.localize('privatePortIcon', 'Icon representing a private remote port.'))));
+const forwardPortIcon = ( registerIcon('ports-forward-icon', Codicon.plus, ( nls.localize('forwardPortIcon', 'Icon for the forward action.'))));
+const stopForwardIcon = ( registerIcon('ports-stop-forward-icon', Codicon.x, ( nls.localize('stopForwardIcon', 'Icon for the stop forwarding action.'))));
+const openBrowserIcon = ( registerIcon('ports-open-browser-icon', Codicon.globe, ( nls.localize('openBrowserIcon', 'Icon for the open browser action.'))));
+const openPreviewIcon = ( registerIcon('ports-open-preview-icon', Codicon.openPreview, ( nls.localize('openPreviewIcon', 'Icon for the open preview action.'))));
+const copyAddressIcon = ( registerIcon('ports-copy-address-icon', Codicon.clippy, ( nls.localize('copyAddressIcon', 'Icon for the copy local address action.'))));
+const labelPortIcon = ( registerIcon('ports-label-icon', Codicon.tag, ( nls.localize('labelPortIcon', 'Icon for the label port action.'))));
+const forwardedPortWithoutProcessIcon = ( registerIcon(
+ 'ports-forwarded-without-process-icon',
+ Codicon.circleOutline,
+ ( nls.localize(
+  'forwardedPortWithoutProcessIcon',
+  'Icon for forwarded ports that don\'t have a running process.'
+ ))
+));
+const forwardedPortWithProcessIcon = ( registerIcon('ports-forwarded-with-process-icon', Codicon.circleFilled, ( nls.localize(
+ 'forwardedPortWithProcessIcon',
+ 'Icon for forwarded ports that do have a running process.'
+))));
+export { copyAddressIcon, forwardPortIcon, forwardedPortWithProcessIcon, forwardedPortWithoutProcessIcon, labelPortIcon, openBrowserIcon, openPreviewIcon, privatePortIcon, stopForwardIcon };