@gitpod/gitpod-protocol 0.1.5-patch-1-fork.0 → 0.1.5-pd-del-private-repo-check-fork.0

package/src/gitpod-service.ts

@@ -5,14 +5,19 @@
  */
 
 import {
-    User, WorkspaceInfo, WorkspaceCreationResult, UserMessage, WorkspaceInstanceUser,
+    User, WorkspaceInfo, WorkspaceCreationResult, WorkspaceInstanceUser,
     WhitelistedRepository, WorkspaceImageBuild, AuthProviderInfo, Branding, CreateWorkspaceMode,
     Token, UserEnvVarValue, ResolvePluginsParams, PreparePluginUploadParams, Terms,
-    ResolvedPlugins, Configuration, InstallPluginsParams, UninstallPluginParams, UserInfo, GitpodTokenType, GitpodToken, AuthProviderEntry
+    ResolvedPlugins, Configuration, InstallPluginsParams, UninstallPluginParams, UserInfo, GitpodTokenType,
+    GitpodToken, AuthProviderEntry, GuessGitTokenScopesParams, GuessedGitTokenScopes
 } from './protocol';
+import {
+    Team, TeamMemberInfo,
+    TeamMembershipInvite, Project, TeamMemberRole, PrebuildWithStatus, StartPrebuildResult
+} from './teams-projects-protocol';
 import { JsonRpcProxy, JsonRpcServer } from './messaging/proxy-factory';
 import { Disposable, CancellationTokenSource } from 'vscode-jsonrpc';
-import { HeadlessLogEvent } from './headless-workspace-log';
+import { HeadlessLogUrls } from './headless-workspace-log';
 import { WorkspaceInstance, WorkspaceInstancePort, WorkspaceInstancePhase } from './workspace-instance';
 import { AdminServer } from './admin-protocol';
 import { GitpodHostUrl } from './util/gitpod-host-url';
@@ -23,11 +28,13 @@ import { Emitter } from './util/event';
 import { AccountStatement, CreditAlert } from './accounting-protocol';
 import { GithubUpgradeURL, PlanCoupon } from './payment-protocol';
 import { TeamSubscription, TeamSubscriptionSlot, TeamSubscriptionSlotResolved } from './team-subscription-protocol';
+import { RemotePageMessage, RemoteTrackMessage, RemoteIdentifyMessage } from './analytics';
 
 export interface GitpodClient {
     onInstanceUpdate(instance: WorkspaceInstance): void;
     onWorkspaceImageBuildLogs: WorkspaceImageBuild.LogCallback;
-    onHeadlessWorkspaceLogs(evt: HeadlessLogEvent): void;
+
+    onPrebuildUpdate(update: PrebuildWithStatus): void;
 
     onCreditAlert(creditAlert: CreditAlert): void;
 
@@ -45,11 +52,12 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     updateLoggedInUser(user: Partial<User>): Promise<User>;
     getAuthProviders(): Promise<AuthProviderInfo[]>;
     getOwnAuthProviders(): Promise<AuthProviderEntry[]>;
-    updateOwnAuthProvider(params: GitpodServer.UpdateOwnAuthProviderParams): Promise<void>;
+    updateOwnAuthProvider(params: GitpodServer.UpdateOwnAuthProviderParams): Promise<AuthProviderEntry>;
     deleteOwnAuthProvider(params: GitpodServer.DeleteOwnAuthProviderParams): Promise<void>;
     getBranding(): Promise<Branding>;
     getConfiguration(): Promise<Configuration>;
     getToken(query: GitpodServer.GetTokenSearchOptions): Promise<Token | undefined>;
+    getGitpodTokenScopes(tokenHash: string): Promise<string[]>;
     /**
      * @deprecated
      */
@@ -81,8 +89,8 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     updateWorkspaceUserPin(id: string, action: GitpodServer.PinAction): Promise<void>;
     sendHeartBeat(options: GitpodServer.SendHeartBeatOptions): Promise<void>;
     watchWorkspaceImageBuildLogs(workspaceId: string): Promise<void>;
-    watchHeadlessWorkspaceLogs(workspaceId: string): Promise<void>;
     isPrebuildDone(pwsid: string): Promise<boolean>;
+    getHeadlessLog(instanceId: string): Promise<HeadlessLogUrls>;
 
     // Workspace timeout
     setWorkspaceTimeout(workspaceId: string, duration: WorkspaceTimeoutDuration): Promise<SetWorkspaceTimeoutResult>;
@@ -96,19 +104,41 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     openPort(workspaceId: string, port: WorkspaceInstancePort): Promise<WorkspaceInstancePort | undefined>;
     closePort(workspaceId: string, port: number): Promise<void>;
 
-    // User messages
-    getUserMessages(options: GitpodServer.GetUserMessagesOptions): Promise<UserMessage[]>;
-    updateUserMessages(options: GitpodServer.UpdateUserMessagesOptions): Promise<void>;
-
     // User storage
     getUserStorageResource(options: GitpodServer.GetUserStorageResourceOptions): Promise<string>;
     updateUserStorageResource(options: GitpodServer.UpdateUserStorageResourceOptions): Promise<void>;
 
-    // user env vars
+    // User env vars
     getEnvVars(): Promise<UserEnvVarValue[]>;
+    getAllEnvVars(): Promise<UserEnvVarValue[]>;
     setEnvVar(variable: UserEnvVarValue): Promise<void>;
     deleteEnvVar(variable: UserEnvVarValue): Promise<void>;
 
+    // Teams
+    getTeams(): Promise<Team[]>;
+    getTeamMembers(teamId: string): Promise<TeamMemberInfo[]>;
+    createTeam(name: string): Promise<Team>;
+    joinTeam(inviteId: string): Promise<Team>;
+    setTeamMemberRole(teamId: string, userId: string, role: TeamMemberRole): Promise<void>;
+    removeTeamMember(teamId: string, userId: string): Promise<void>;
+    getGenericInvite(teamId: string): Promise<TeamMembershipInvite>;
+    resetGenericInvite(inviteId: string): Promise<TeamMembershipInvite>;
+    deleteTeam(teamId: string, userId: string): Promise<void>;
+
+    // Projects
+    getProviderRepositoriesForUser(params: GetProviderRepositoriesParams): Promise<ProviderRepository[]>;
+    createProject(params: CreateProjectParams): Promise<Project>;
+    deleteProject(projectId: string): Promise<void>;
+    getTeamProjects(teamId: string): Promise<Project[]>;
+    getUserProjects(): Promise<Project[]>;
+    getProjectOverview(projectId: string): Promise<Project.Overview | undefined>;
+    findPrebuilds(params: FindPrebuildsParams): Promise<PrebuildWithStatus[]>;
+    triggerPrebuild(projectId: string, branchName: string | null): Promise<StartPrebuildResult>;
+    cancelPrebuild(projectId: string, prebuildId: string): Promise<void>;
+    setProjectConfiguration(projectId: string, configString: string): Promise<void>;
+    fetchProjectRepositoryConfiguration(projectId: string): Promise<string | undefined>;
+    guessProjectConfiguration(projectId: string): Promise<string | undefined>;
+
     // content service
     getContentBlobUploadUrl(name: string): Promise<string>
     getContentBlobDownloadUrl(name: string): Promise<string>
@@ -123,10 +153,15 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     registerGithubApp(installationId: string): Promise<void>;
 
     /**
-     * Stores a new snapshot for the given workspace and bucketId
+     * Stores a new snapshot for the given workspace and bucketId. Returns _before_ the actual snapshot is done. To wait for that, use `waitForSnapshot`.
      * @return the snapshot id
      */
     takeSnapshot(options: GitpodServer.TakeSnapshotOptions): Promise<string>;
+    /**
+     *
+     * @param snapshotId
+     */
+    waitForSnapshot(snapshotId: string): Promise<void>;
 
     /**
      * Returns the list of snapshots that exist for a workspace.
@@ -152,20 +187,20 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     installUserPlugins(params: InstallPluginsParams): Promise<boolean>;
     uninstallUserPlugin(params: UninstallPluginParams): Promise<boolean>;
 
+    guessGitTokenScopes(params: GuessGitTokenScopesParams): Promise<GuessedGitTokenScopes>;
+
     /**
      * gitpod.io concerns
      */
     isStudent(): Promise<boolean>;
-    getPrivateRepoTrialEndDate(): Promise<string | undefined>;
-
     /**
-     * 
+     *
      */
     getAccountStatement(options: GitpodServer.GetAccountStatementOptions): Promise<AccountStatement | undefined>;
     getRemainingUsageHours(): Promise<number>;
 
     /**
-     * 
+     *
      */
     getChargebeeSiteId(): Promise<string>;
     createPortalSession(): Promise<{}>;
@@ -175,7 +210,6 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
 
     getShowPaymentUI(): Promise<boolean>;
     isChargebeeCustomer(): Promise<boolean>;
-    mayAccessPrivateRepo(): Promise<boolean>;
 
     subscriptionUpgradeTo(subscriptionId: string, chargebeePlanId: string): Promise<void>;
     subscriptionDowngradeTo(subscriptionId: string, chargebeePlanId: string): Promise<void>;
@@ -186,13 +220,61 @@ export interface GitpodServer extends JsonRpcServer<GitpodClient>, AdminServer,
     tsGetSlots(): Promise<TeamSubscriptionSlotResolved[]>;
     tsGetUnassignedSlot(teamSubscriptionId: string): Promise<TeamSubscriptionSlot | undefined>
     tsAddSlots(teamSubscriptionId: string, quantity: number): Promise<void>;
-    tsAssignSlot(teamSubscriptionId: string, teamSubscriptionSlotId: string, identityStr: string|undefined): Promise<void>
+    tsAssignSlot(teamSubscriptionId: string, teamSubscriptionSlotId: string, identityStr: string | undefined): Promise<void>
     tsReassignSlot(teamSubscriptionId: string, teamSubscriptionSlotId: string, newIdentityStr: string): Promise<void>;
     tsDeactivateSlot(teamSubscriptionId: string, teamSubscriptionSlotId: string): Promise<void>;
     tsReactivateSlot(teamSubscriptionId: string, teamSubscriptionSlotId: string): Promise<void>;
 
     getGithubUpgradeUrls(): Promise<GithubUpgradeURL[]>;
 
+    /**
+     * Analytics
+     */
+    trackEvent(event: RemoteTrackMessage): Promise<void>;
+    trackLocation(event: RemotePageMessage): Promise<void>;
+    identifyUser(event: RemoteIdentifyMessage): Promise<void>;
+}
+
+export interface CreateProjectParams {
+    name: string;
+    slug?: string;
+    account: string;
+    provider: string;
+    cloneUrl: string;
+    teamId?: string;
+    userId?: string;
+    appInstallationId: string;
+}
+export interface FindPrebuildsParams {
+    projectId: string;
+    branch?: string;
+    latest?: boolean;
+    prebuildId?: string;
+    // default: 30
+    limit?: number;
+}
+export interface GetProviderRepositoriesParams {
+    provider: string;
+    hints?: { installationId: string } | object;
+}
+export interface ProviderRepository {
+    name: string;
+    path?: string;
+    account: string;
+    accountAvatarUrl: string;
+    cloneUrl: string;
+    updatedAt: string;
+    installationId?: number;
+    installationUpdatedAt?: string;
+
+    inUse?: boolean;
+}
+
+export interface ClientHeaderFields{
+    ip?: string;
+    userAgent?: string;
+    dnt?: string;
+    clientRegion?: string;
 }
 
 export const WorkspaceTimeoutValues = ["30m", "60m", "180m"] as const;
@@ -205,6 +287,7 @@ export const createServerMock = function <C extends GitpodClient, S extends Gitp
     methods.setClient = methods.setClient || (() => { });
     methods.dispose = methods.dispose || (() => { });
     return new Proxy<JsonRpcProxy<S>>(methods as any as JsonRpcProxy<S>, {
+        // @ts-ignore
         get: (target: S, property: keyof S) => {
             const result = target[property];
             if (!result) {
@@ -237,6 +320,8 @@ export namespace GitpodServer {
         limit?: number;
         searchString?: string;
         pinnedOnly?: boolean;
+        projectId?: string | string[];
+        includeWithoutProject?: boolean;
     }
     export interface GetAccountStatementOptions {
         date?: string;
@@ -244,6 +329,7 @@ export namespace GitpodServer {
     export interface CreateWorkspaceOptions {
         contextUrl: string;
         mode?: CreateWorkspaceMode;
+        forceDefaultConfig?: boolean;
     }
     export interface StartWorkspaceOptions {
         forceDefaultImage: boolean;
@@ -251,13 +337,8 @@ export namespace GitpodServer {
     export interface TakeSnapshotOptions {
         workspaceId: string;
         layoutData?: string;
-    }
-    export interface GetUserMessagesOptions {
-        readonly releaseNotes?: boolean;
-        readonly workspaceInstanceId: string;
-    }
-    export interface UpdateUserMessagesOptions {
-        readonly messageIds: string[];
+        /* this is here to enable backwards-compatibility and untangling rollout between workspace, IDE and meta */
+        dontWait?: boolean;
     }
     export interface GetUserStorageResourceOptions {
         readonly uri: string;
@@ -319,11 +400,11 @@ export class GitpodCompositeClient<Client extends GitpodClient> implements Gitpo
         }
     }
 
-    onWorkspaceImageBuildLogs(info: WorkspaceImageBuild.StateInfo, content: WorkspaceImageBuild.LogContent | undefined): void {
+    onPrebuildUpdate(update: PrebuildWithStatus): void {
         for (const client of this.clients) {
-            if (client.onWorkspaceImageBuildLogs) {
+            if (client.onPrebuildUpdate) {
                 try {
-                    client.onWorkspaceImageBuildLogs(info, content);
+                    client.onPrebuildUpdate(update);
                 } catch (error) {
                     console.error(error)
                 }
@@ -331,11 +412,11 @@ export class GitpodCompositeClient<Client extends GitpodClient> implements Gitpo
         }
     }
 
-    onHeadlessWorkspaceLogs(evt: HeadlessLogEvent): void {
+    onWorkspaceImageBuildLogs(info: WorkspaceImageBuild.StateInfo, content: WorkspaceImageBuild.LogContent | undefined): void {
         for (const client of this.clients) {
-            if (client.onHeadlessWorkspaceLogs) {
+            if (client.onWorkspaceImageBuildLogs) {
                 try {
-                    client.onHeadlessWorkspaceLogs(evt);
+                    client.onWorkspaceImageBuildLogs(info, content);
                 } catch (error) {
                     console.error(error)
                 }
@@ -399,7 +480,7 @@ export class WorkspaceInstanceUpdateListener {
     private readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
-    private source: 'sync' | 'update' = 'sync';
+    private source: 'sync' | 'update' = 'sync';
 
     get info(): WorkspaceInfo {
         return this._info;
@@ -491,11 +572,15 @@ export class WorkspaceInstanceUpdateListener {
 
 }
 
+export interface GitpodServiceOptions {
+    onReconnect?: () => (void | Promise<void>)
+}
+
 export class GitpodServiceImpl<Client extends GitpodClient, Server extends GitpodServer> {
 
     private readonly compositeClient = new GitpodCompositeClient<Client>();
 
-    constructor(public readonly server: JsonRpcProxy<Server>) {
+    constructor(public readonly server: JsonRpcProxy<Server>, private options?: GitpodServiceOptions) {
         server.setClient(this.compositeClient);
         server.onDidOpenConnection(() => this.compositeClient.notifyDidOpenConnection());
         server.onDidCloseConnection(() => this.compositeClient.notifyDidCloseConnection());
@@ -515,13 +600,34 @@ export class GitpodServiceImpl<Client extends GitpodClient, Server extends Gitpo
         this.instanceListeners.set(workspaceId, listener);
         return listener;
     }
+
+    async reconnect(): Promise<void> {
+        if (this.options?.onReconnect) {
+            await this.options.onReconnect();
+        }
+    }
 }
 
-export function createGitpodService<C extends GitpodClient, S extends GitpodServer>(serverUrl: string) {
-    const url = new GitpodHostUrl(serverUrl)
-        .asWebsocket()
-        .withApi({ pathname: GitpodServerPath });
+export function createGitpodService<C extends GitpodClient, S extends GitpodServer>(serverUrl: string | Promise<string>) {
+    const toWsUrl = (serverUrl: string) => {
+        return new GitpodHostUrl(serverUrl)
+            .asWebsocket()
+            .withApi({ pathname: GitpodServerPath })
+            .toString();
+    };
+    let url: string | Promise<string>;
+    if (typeof serverUrl === "string") {
+        url = toWsUrl(serverUrl);
+    } else {
+        url = serverUrl.then(url => toWsUrl(url));
+    }
+
     const connectionProvider = new WebSocketConnectionProvider();
-    const gitpodServer = connectionProvider.createProxy<S>(url.toString());
-    return new GitpodServiceImpl<C, S>(gitpodServer);
+    let onReconnect = () => { };
+    const gitpodServer = connectionProvider.createProxy<S>(url, undefined, {
+        onListening: socket => {
+            onReconnect = () => socket.reconnect();
+        }
+    });
+    return new GitpodServiceImpl<C, S>(gitpodServer, { onReconnect });
 }

package/src/headless-workspace-log.ts

@@ -22,21 +22,17 @@ export namespace HeadlessWorkspaceEventType {
     }
 }
 
-export interface HeadlessLogEvent {
+export interface HeadlessWorkspaceEvent {
     workspaceID: string;
     text: string;
     type: HeadlessWorkspaceEventType;
 }
 
-export enum TheiaHeadlessLogType {
-    TaskLogLabel = "workspaceTaskOutput",
-    TaskFailedLabel = "workspaceTaskFailed",
-    TaskSuccessfulLabel = "workspaceTaskDone"
+export interface HeadlessLogUrls {
+    // A map of id to URL
+    streams: { [streamID: string]: string };
 }
 
-export interface TheiaHeadlessLogMessage {
-    type: TheiaHeadlessLogType;
-    data?: string;
-    error?: string;
-    snapshotURL?: string;
-}
+/** cmp. @const HEADLESS_LOG_STREAM_STATUS_CODE_REGEX */
+export const HEADLESS_LOG_STREAM_STATUS_CODE = "X-LogStream-StatusCode";
+export const HEADLESS_LOG_STREAM_STATUS_CODE_REGEX = /X-LogStream-StatusCode: ([0-9]{3})/;

package/src/index.ts

@@ -13,4 +13,8 @@ export * from './license-protocol';
 export * from './workspace-instance';
 export * from './permission';
 export * from './admin-protocol';
-export * from './email-protocol';
+export * from './email-protocol';
+export * from './headless-workspace-log';
+export * from './context-url';
+export * from './teams-projects-protocol';
+export * from './snapshot-url';

package/src/messaging/browser/connection.ts

@@ -5,13 +5,17 @@
  * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
  */
 
-import { listen as doListen, Logger, ConsoleLogger } from "vscode-ws-jsonrpc";
+import { Logger, ConsoleLogger, toSocket, IWebSocket } from "vscode-ws-jsonrpc";
+import { createMessageConnection } from "vscode-jsonrpc";
+import { AbstractMessageWriter } from "vscode-jsonrpc/lib/messageWriter";
+import { AbstractMessageReader } from "vscode-jsonrpc/lib/messageReader";
 import { JsonRpcProxyFactory, JsonRpcProxy } from "../proxy-factory";
-import { ConnectionHandler } from "../handler";
-import ReconnectingWebSocket from 'reconnecting-websocket';
+import { ConnectionEventHandler, ConnectionHandler } from "../handler";
+import ReconnectingWebSocket, { Event } from 'reconnecting-websocket';
 
 export interface WebSocketOptions {
     onerror?: (event: Event) => void;
+    onListening?: (socket: ReconnectingWebSocket) => void;
 }
 
 export class WebSocketConnectionProvider {
@@ -23,19 +27,35 @@ export class WebSocketConnectionProvider {
      * An optional target can be provided to handle
      * notifications and requests from a remote side.
      */
-    createProxy<T extends object>(path: string, target?: object, options?: WebSocketOptions): JsonRpcProxy<T> {
+    createProxy<T extends object>(path: string | Promise<string>, target?: object, options?: WebSocketOptions): JsonRpcProxy<T> {
         const factory = new JsonRpcProxyFactory<T>(target);
-        this.listen({
-            path,
-            onConnection: c => factory.listen(c)
-        }, options);
+        const startListening = (path: string) => {
+            const socket = this.listen({
+                path,
+                onConnection: c => factory.listen(c),
+            }, {
+                onTransportDidClose: () => factory.fireConnectionClosed(),
+                onTransportDidOpen: () => factory.fireConnectionOpened(),
+            },
+                options
+            );
+            if (options?.onListening) {
+                options.onListening(socket as any as ReconnectingWebSocket)
+            }
+        };
+
+        if (typeof path === "string") {
+            startListening(path);
+        } else {
+            path.then(path => startListening(path));
+        }
         return factory.createProxy();
     }
 
     /**
      * Install a connection handler for the given path.
      */
-    listen(handler: ConnectionHandler, options?: WebSocketOptions): void {
+    listen(handler: ConnectionHandler, eventHandler: ConnectionEventHandler, options?: WebSocketOptions): WebSocket {
         const url = handler.path;
         const webSocket = this.createWebSocket(url);
 
@@ -50,11 +70,13 @@ export class WebSocketConnectionProvider {
                 logger.error(JSON.stringify(error));
             });
         }
-        doListen({
-            webSocket,
-            onConnection: connection => handler.onConnection(connection),
-            logger
-        });
+        doListen(
+            webSocket as any as ReconnectingWebSocket,
+            handler,
+            eventHandler,
+            logger,
+        );
+        return webSocket;
     }
 
     protected createLogger(): Logger {
@@ -76,3 +98,162 @@ export class WebSocketConnectionProvider {
     }
 
 }
+
+// The following was extracted from vscode-ws-jsonrpc to make these changes:
+//  - switch from WebSocket to ReconnectingWebSocket
+//  - webSocket.onopen: making sure it's only ever called once so we're re-using MessageConnection
+//  - WebSocketMessageWriter: buffer and re-try messages instead of throwing an error immidiately
+//  - WebSocketMessageReader: don't close MessageConnection on 'socket.onclose'
+function doListen(resocket: ReconnectingWebSocket, handler: ConnectionHandler, eventHandler: ConnectionEventHandler, logger: Logger) {
+    resocket.addEventListener("close", () => eventHandler.onTransportDidClose());
+
+    let alreadyOpened = false;
+    resocket.onopen = () => {
+        // trigerr "open" every time we re-open the underlying websocket
+        eventHandler.onTransportDidOpen();
+
+        // make sure we're only ever creating one MessageConnection, irregardless of how many times we have to re-open the underlying (reconnecting) websocket
+        if (alreadyOpened) {
+            return;
+        }
+        alreadyOpened = true;
+
+        const connection = createWebSocketConnection(resocket, logger);
+        handler.onConnection(connection);
+    };
+}
+
+function createWebSocketConnection(resocket: ReconnectingWebSocket, logger: Logger) {
+    const socket = toSocket(resocket as any);
+    const messageReader = new NonClosingWebSocketMessageReader(socket);
+    const messageWriter = new BufferingWebSocketMessageWriter(resocket, logger);
+    const connection = createMessageConnection(messageReader, messageWriter, logger);
+    connection.onClose(() => connection.dispose());
+    return connection;
+}
+
+/**
+ * This takes vscode-ws-jsonrpc/lib/socket/writer/WebSocketMessageWriter and adds a buffer
+ */
+class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
+    protected readonly socket: ReconnectingWebSocket;
+    protected readonly logger: Logger;
+    protected errorCount: number = 0;
+
+    protected buffer: any[] = [];
+
+    constructor(socket: ReconnectingWebSocket, logger: Logger) {
+        super();
+        this.socket = socket;
+        this.logger = logger;
+
+        socket.addEventListener("open", (event: Event) => this.flushBuffer());
+    }
+
+    write(msg: any) {
+        if (this.socket.readyState !== ReconnectingWebSocket.OPEN) {
+            this.bufferMsg(msg);
+            return;
+        }
+
+        try {
+            const content = JSON.stringify(msg);
+            this.socket.send(content);
+        } catch (e) {
+            this.errorCount++;
+            this.fireError(e, msg, this.errorCount);
+
+            this.bufferMsg(msg);
+        }
+    }
+
+    protected flushBuffer() {
+        if (this.buffer.length === 0) {
+            return
+        }
+
+        const buffer = [...this.buffer];
+        this.buffer = [];
+        for (const msg of buffer) {
+            this.write(msg);
+        }
+        //this.logger.info(`flushed buffer (${this.buffer.length})`)
+    }
+
+    protected bufferMsg(msg: any) {
+        this.buffer.push(msg);
+        //this.logger.info(`buffered message (${this.buffer.length})`);
+    }
+}
+
+
+/**
+ * This takes vscode-ws-jsonrpc/lib/socket/reader/WebSocketMessageReader and removes the "onClose -> fireClose" connection
+ */
+class NonClosingWebSocketMessageReader extends AbstractMessageReader {
+    protected readonly socket: IWebSocket;
+    protected readonly events: any[] = [];
+    protected state: 'initial' | 'listening' | 'closed' = 'initial';
+    protected callback: (message: any) => void = () => {};
+
+    constructor(socket: IWebSocket) {
+        super();
+        this.socket = socket;
+        this.socket.onMessage(message => this.readMessage(message));
+        this.socket.onError(error => this.fireError(error));
+        this.socket.onClose((code, reason) => {
+            if (code !== 1000) {
+                const error = {
+                    name: '' + code,
+                    message: `Error during socket reconnect: code = ${code}, reason = ${reason}`
+                };
+                this.fireError(error);
+            }
+            // this.fireClose();        // <-- reason for this class to be copied over
+        });
+    }
+    listen(callback: (message: any) => void) {
+        if (this.state === 'initial') {
+            this.state = 'listening';
+            this.callback = callback;
+            while (this.events.length !== 0) {
+                const event = this.events.pop();
+                if (event.message) {
+                    this.readMessage(event.message);
+                }
+                else if (event.error) {
+                    this.fireError(event.error);
+                }
+                else {
+                    this.fireClose();
+                }
+            }
+        }
+    }
+    readMessage(message: any) {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { message });
+        }
+        else if (this.state === 'listening') {
+            const data = JSON.parse(message);
+            this.callback(data);
+        }
+    }
+    fireError(error: any) {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, { error });
+        }
+        else if (this.state === 'listening') {
+            super.fireError(error);
+        }
+    }
+    fireClose() {
+        if (this.state === 'initial') {
+            this.events.splice(0, 0, {});
+        }
+        else if (this.state === 'listening') {
+            super.fireClose();
+        }
+        this.state = 'closed';
+    }
+}