@gitpod/gitpod-protocol 0.1.5-to-code-reading.1 → 0.1.5-to-monitor-delete.18

package/src/headless-workspace-log.ts

@@ -4,21 +4,23 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
 export enum HeadlessWorkspaceEventType {
     LogOutput = "log-output",
     FinishedSuccessfully = "finish-success",
     FinishedButFailed = "finish-fail",
     AbortedTimedOut = "aborted-timeout",
     Aborted = "aborted",
-    Started = "started"
+    Failed = "failed",
+    Started = "started",
 }
 export namespace HeadlessWorkspaceEventType {
     export function isRunning(t: HeadlessWorkspaceEventType) {
         return t === HeadlessWorkspaceEventType.LogOutput;
     }
     export function didFinish(t: HeadlessWorkspaceEventType) {
-        return t === HeadlessWorkspaceEventType.FinishedButFailed || t === HeadlessWorkspaceEventType.FinishedSuccessfully;
+        return (
+            t === HeadlessWorkspaceEventType.FinishedButFailed || t === HeadlessWorkspaceEventType.FinishedSuccessfully
+        );
     }
 }
 
@@ -35,4 +37,4 @@ export interface HeadlessLogUrls {
 
 /** 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})/;
+export const HEADLESS_LOG_STREAM_STATUS_CODE_REGEX = /X-LogStream-StatusCode: ([0-9]{3})/;

package/src/ide-frontend-service.ts

@@ -7,7 +7,7 @@
 import { Event } from "./util/event";
 import { Disposable } from "./util/disposable";
 
-export type IDEFrontendState = 'init' | 'ready' | 'terminated';
+export type IDEFrontendState = "init" | "ready" | "terminated";
 
 export interface IDEFrontendService {
     readonly state: IDEFrontendState;
@@ -25,4 +25,4 @@ export interface IDEFrontendService {
      * confirmation dialogs for stopped workspaces.
      */
     start(): Disposable;
-}
+}

package/src/ide-protocol.ts

@@ -29,6 +29,28 @@ export interface IDEOptions {
      * The default desktop IDE when the user has not specified one.
      */
     defaultDesktopIde: string;
+
+    /**
+     * Client specific IDE options.
+     */
+    clients?: { [id: string]: IDEClient };
+}
+
+export interface IDEClient {
+    /**
+     * The default desktop IDE when the user has not specified one.
+     */
+    defaultDesktopIDE?: string;
+
+    /**
+     * Desktop IDEs supported by the client.
+     */
+    desktopIDEs?: string[];
+
+    /**
+     * Steps to install the client on user machine.
+     */
+    installationSteps?: string[];
 }
 
 export interface IDEOption {
@@ -45,12 +67,12 @@ export interface IDEOption {
     /**
      * The type of the IDE, currently 'browser' or 'desktop'.
      */
-    type: 'browser' | 'desktop';
+    type: "browser" | "desktop";
 
     /**
-    * The logo for the IDE. That could be a key in (see
-    * components/dashboard/src/images/ideLogos.ts) or a URL.
-    */
+     * The logo for the IDE. That could be a key in (see
+     * components/dashboard/src/images/ideLogos.ts) or a URL.
+     */
     logo: string;
 
     /**
@@ -71,8 +93,8 @@ export interface IDEOption {
     notes?: string[];
 
     /**
-    * If `true` this IDE option is not visible in the IDE preferences.
-    */
+     * If `true` this IDE option is not visible in the IDE preferences.
+     */
     hidden?: boolean;
 
     /**
@@ -80,6 +102,11 @@ export interface IDEOption {
      */
     image: string;
 
+    /**
+     * The latest image ref to the IDE image, this image ref always resolve to digest.
+     */
+    latestImage?: string;
+
     /**
      * When this is `true`, the tag of this image is resolved to the latest
      * image digest regularly.
@@ -89,4 +116,14 @@ export interface IDEOption {
      * we resolve the tag regularly to the most recent image version.
      */
     resolveImageDigest?: boolean;
+
+    /**
+     * The plugin image ref for the IDE image, this image ref always resolve to digest.
+     */
+    pluginImage?: string;
+
+    /**
+     * The latest plugin image ref for the latest IDE image, this image ref always resolve to digest.
+     */
+    pluginLatestImage?: string;
 }

package/src/index.ts

@@ -4,18 +4,19 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-export * from './protocol';
-export * from './gitpod-service';
-export * from './util/disposable';
-export * from './util/event';
-export * from './util/queue';
-export * from './license-protocol';
-export * from './workspace-instance';
-export * from './permission';
-export * from './admin-protocol';
-export * from './email-protocol';
-export * from './headless-workspace-log';
-export * from './context-url';
-export * from './teams-projects-protocol';
-export * from './snapshot-url';
-export * from './oss-allowlist';
+export * from "./protocol";
+export * from "./gitpod-service";
+export * from "./util/disposable";
+export * from "./util/event";
+export * from "./util/queue";
+export * from "./license-protocol";
+export * from "./workspace-instance";
+export * from "./permission";
+export * from "./admin-protocol";
+export * from "./headless-workspace-log";
+export * from "./context-url";
+export * from "./teams-projects-protocol";
+export * from "./snapshot-url";
+export * from "./oss-allowlist";
+export * from "./installation-admin-protocol";
+export * from "./webhook-event";

package/src/installation-admin-protocol.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+import { v4 as uuidv4 } from "uuid";
+
+const InstallationAdminSettingsPrototype = {
+    sendTelemetry: true,
+    sendCustomerID: true,
+};
+
+export type InstallationAdminSettings = typeof InstallationAdminSettingsPrototype;
+
+export namespace InstallationAdminSettings {
+    export function fields(): (keyof InstallationAdminSettings)[] {
+        return Object.keys(InstallationAdminSettingsPrototype) as (keyof InstallationAdminSettings)[];
+    }
+}
+
+export interface InstallationAdmin {
+    id: string;
+    settings: InstallationAdminSettings;
+}
+
+export interface TelemetryData {
+    installationAdmin: InstallationAdmin;
+    totalUsers: number;
+    totalWorkspaces: number;
+    totalInstances: number;
+    licenseType: string;
+    customerID?: string;
+}
+
+export namespace InstallationAdmin {
+    export function createDefault(): InstallationAdmin {
+        return {
+            id: uuidv4(),
+            settings: {
+                ...InstallationAdminSettingsPrototype,
+            },
+        };
+    }
+}

package/src/license-protocol.ts

@@ -4,11 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
 export interface LicenseValidationResult {
-    valid: boolean
-    msg?: string
-    issue?: LicenseIssue
+    valid: boolean;
+    msg?: string;
+    issue?: LicenseIssue;
 }
 
 export type LicenseIssue = "seats-exhausted";
@@ -16,9 +15,15 @@ export type LicenseIssue = "seats-exhausted";
 export interface LicenseInfo {
     key: string;
     seats: number;
+    userCount?: number;
     valid: boolean;
     validUntil: string;
     plan?: string;
+    features?: string[];
+    enabledFeatures?: string[];
+    type?: string;
+    errorMsg?: string;
+    fallbackAllowed: boolean;
 }
 
 export interface GetLicenseInfoResult {
@@ -34,5 +39,6 @@ export enum LicenseFeature {
 export interface LicenseService {
     validateLicense(): Promise<LicenseValidationResult>;
     getLicenseInfo(): Promise<GetLicenseInfoResult>;
-    licenseIncludesFeature(feature: LicenseFeature): Promise<boolean>
-}
+    adminGetLicense(): Promise<LicenseInfo>;
+    licenseIncludesFeature(feature: LicenseFeature): Promise<boolean>;
+}

package/src/messaging/browser/connection.ts

@@ -11,7 +11,7 @@ import { AbstractMessageWriter } from "vscode-jsonrpc/lib/messageWriter";
 import { AbstractMessageReader } from "vscode-jsonrpc/lib/messageReader";
 import { JsonRpcProxyFactory, JsonRpcProxy } from "../proxy-factory";
 import { ConnectionEventHandler, ConnectionHandler } from "../handler";
-import ReconnectingWebSocket, { Event } from 'reconnecting-websocket';
+import ReconnectingWebSocket, { Event } from "reconnecting-websocket";
 
 export interface WebSocketOptions {
     onerror?: (event: Event) => void;
@@ -19,7 +19,6 @@ export interface WebSocketOptions {
 }
 
 export class WebSocketConnectionProvider {
-
     /**
      * Create a proxy object to remote interface of T type
      * over a web socket connection for the given path.
@@ -27,27 +26,33 @@ export class WebSocketConnectionProvider {
      * An optional target can be provided to handle
      * notifications and requests from a remote side.
      */
-    createProxy<T extends object>(path: string | Promise<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);
         const startListening = (path: string) => {
-            const socket = this.listen({
-                path,
-                onConnection: c => factory.listen(c),
-            }, {
-                onTransportDidClose: () => factory.fireConnectionClosed(),
-                onTransportDidOpen: () => factory.fireConnectionOpened(),
-            },
-                options
+            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)
+                options.onListening(socket as any as ReconnectingWebSocket);
             }
         };
 
         if (typeof path === "string") {
             startListening(path);
         } else {
-            path.then(path => startListening(path));
+            path.then((path) => startListening(path));
         }
         return factory.createProxy();
     }
@@ -62,20 +67,15 @@ export class WebSocketConnectionProvider {
         const logger = this.createLogger();
         if (options && options.onerror) {
             const onerror = options.onerror;
-            webSocket.addEventListener('error', (event) => {
+            webSocket.addEventListener("error", (event) => {
                 onerror(event);
             });
         } else {
-            webSocket.addEventListener('error', (error: Event) => {
+            webSocket.addEventListener("error", (error: Event) => {
                 logger.error(JSON.stringify(error));
             });
         }
-        doListen(
-            webSocket as any as ReconnectingWebSocket,
-            handler,
-            eventHandler,
-            logger,
-        );
+        doListen(webSocket as any as ReconnectingWebSocket, handler, eventHandler, logger);
         return webSocket;
     }
 
@@ -93,10 +93,9 @@ export class WebSocketConnectionProvider {
             reconnectionDelayGrowFactor: 1.3,
             maxRetries: Infinity,
             debug: false,
-            WebSocket: WebSocket
+            WebSocket: WebSocket,
         }) as any;
     }
-
 }
 
 // The following was extracted from vscode-ws-jsonrpc to make these changes:
@@ -104,7 +103,12 @@ export class WebSocketConnectionProvider {
 //  - 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) {
+function doListen(
+    resocket: ReconnectingWebSocket,
+    handler: ConnectionHandler,
+    eventHandler: ConnectionEventHandler,
+    logger: Logger,
+) {
     resocket.addEventListener("close", () => eventHandler.onTransportDidClose());
 
     let alreadyOpened = false;
@@ -169,7 +173,7 @@ class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
 
     protected flushBuffer() {
         if (this.buffer.length === 0) {
-            return
+            return;
         }
 
         const buffer = [...this.buffer];
@@ -186,26 +190,25 @@ class BufferingWebSocketMessageWriter extends AbstractMessageWriter {
     }
 }
 
-
 /**
  * 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 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.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}`
+                    name: "" + code,
+                    message: `Error during socket reconnect: code = ${code}, reason = ${reason}`,
                 };
                 this.fireError(error);
             }
@@ -213,47 +216,42 @@ class NonClosingWebSocketMessageReader extends AbstractMessageReader {
         });
     }
     listen(callback: (message: any) => void) {
-        if (this.state === 'initial') {
-            this.state = 'listening';
+        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) {
+                } else if (event.error) {
                     this.fireError(event.error);
-                }
-                else {
+                } else {
                     this.fireClose();
                 }
             }
         }
     }
     readMessage(message: any) {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, { message });
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             const data = JSON.parse(message);
             this.callback(data);
         }
     }
     fireError(error: any) {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, { error });
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             super.fireError(error);
         }
     }
     fireClose() {
-        if (this.state === 'initial') {
+        if (this.state === "initial") {
             this.events.splice(0, 0, {});
-        }
-        else if (this.state === 'listening') {
+        } else if (this.state === "listening") {
             super.fireClose();
         }
-        this.state = 'closed';
+        this.state = "closed";
     }
 }

package/src/messaging/browser/window-connection.ts

@@ -4,23 +4,27 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { Message } from 'vscode-jsonrpc/lib/messages';
-import { AbstractMessageWriter, MessageWriter } from 'vscode-jsonrpc/lib/messageWriter';
-import { AbstractMessageReader, MessageReader, DataCallback } from 'vscode-jsonrpc/lib/messageReader';
-import { MessageConnection, createMessageConnection } from 'vscode-jsonrpc/lib/main';
-import { ConsoleLogger } from 'vscode-ws-jsonrpc';
+import { Message } from "vscode-jsonrpc/lib/messages";
+import { AbstractMessageWriter, MessageWriter } from "vscode-jsonrpc/lib/messageWriter";
+import { AbstractMessageReader, MessageReader, DataCallback } from "vscode-jsonrpc/lib/messageReader";
+import { MessageConnection, createMessageConnection } from "vscode-jsonrpc/lib/main";
+import { ConsoleLogger } from "vscode-ws-jsonrpc";
 
 interface WindowMessage extends Message {
-    serviceId: string
+    serviceId: string;
 }
 function isWindowMessage(value: any): value is WindowMessage {
-    return !!value && typeof value === 'object' &&
-        ('jsonrpc' in value && typeof value['jsonrpc'] === 'string') &&
-        ('serviceId' in value && typeof value['serviceId'] === 'string');
+    return (
+        !!value &&
+        typeof value === "object" &&
+        "jsonrpc" in value &&
+        typeof value["jsonrpc"] === "string" &&
+        "serviceId" in value &&
+        typeof value["serviceId"] === "string"
+    );
 }
 
 export class WindowMessageWriter extends AbstractMessageWriter implements MessageWriter {
-
     constructor(readonly serviceId: string, readonly window: Window, readonly targetOrigin: string) {
         super();
     }
@@ -29,44 +33,50 @@ export class WindowMessageWriter extends AbstractMessageWriter implements Messag
         const { serviceId } = this;
         this.window.postMessage(Object.assign(msg, { serviceId }), this.targetOrigin);
     }
-
 }
 
 export class WindowMessageReader extends AbstractMessageReader implements MessageReader {
-
     protected callback?: DataCallback;
     protected readonly buffer: Message[] = [];
 
     constructor(readonly serviceId: string, readonly sourceOrigin: string) {
         super();
-        window.addEventListener('message', event => {
-            if (this.sourceOrigin !== '*' && event.origin !== this.sourceOrigin) {
-                return;
-            }
-            if (!isWindowMessage(event.data) || event.data.serviceId !== this.serviceId) {
-                return;
-            }
-            if (this.callback) {
-                this.callback(event.data);
-            } else {
-                this.buffer.push(event.data);
-            }
-        }, false);
+        window.addEventListener(
+            "message",
+            (event) => {
+                if (this.sourceOrigin !== "*" && event.origin !== this.sourceOrigin) {
+                    return;
+                }
+                if (!isWindowMessage(event.data) || event.data.serviceId !== this.serviceId) {
+                    return;
+                }
+                if (this.callback) {
+                    this.callback(event.data);
+                } else {
+                    this.buffer.push(event.data);
+                }
+            },
+            false,
+        );
     }
 
     listen(callback: DataCallback): void {
         let message;
-        while (message = this.buffer.pop()) {
+        while ((message = this.buffer.pop())) {
             callback(message);
         }
         Object.freeze(this.buffer);
         this.callback = callback;
     }
-
 }
 
-export function createWindowMessageConnection(serviceId: string, window: Window, sourceOrigin: string, targetOrigin = sourceOrigin): MessageConnection {
+export function createWindowMessageConnection(
+    serviceId: string,
+    window: Window,
+    sourceOrigin: string,
+    targetOrigin = sourceOrigin,
+): MessageConnection {
     const reader = new WindowMessageReader(serviceId, sourceOrigin);
     const writer = new WindowMessageWriter(serviceId, window, targetOrigin);
     return createMessageConnection(reader, writer, new ConsoleLogger());
-}
+}