@gitpod/gitpod-protocol 0.1.5-sefftinge-create-feature-flag-for-4354.0 → 0.1.5-server-vscode-oauth2.11

package/src/teams-projects-protocol.ts

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2021 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 { PrebuiltWorkspaceState } from "./protocol";
+import uuidv4 = require("uuid/v4");
+
+export interface ProjectConfig {
+    '.gitpod.yml': string;
+}
+
+export interface Project {
+    id: string;
+    name: string;
+    cloneUrl: string;
+    teamId?: string;
+    userId?: string;
+    appInstallationId: string;
+    config?: ProjectConfig;
+    creationTime: string;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+    markedDeleted?: boolean;
+}
+
+export namespace Project {
+    export const create = (project: Omit<Project, 'id' | 'creationTime'>): Project => {
+        return {
+            ...project,
+            id: uuidv4(),
+            creationTime: new Date().toISOString()
+        };
+    }
+
+    export interface Overview {
+        branches: BranchDetails[]
+    }
+
+    export interface BranchDetails {
+        name: string;
+        url: string;
+        isDefault: boolean;
+
+        // Latest commit
+        changeTitle: string;
+        changeDate?: string;
+        changeAuthor?: string;
+        changeAuthorAvatar?: string;
+        changePR?: string;
+        changeUrl?: string;
+        changeHash: string;
+    }
+}
+
+export interface PrebuildWithStatus {
+    info: PrebuildInfo;
+    status: PrebuiltWorkspaceState;
+    error?: string;
+}
+
+export interface PrebuildInfo {
+    id: string;
+    buildWorkspaceId: string;
+
+    teamId?: string;
+    userId?: string;
+
+    projectId: string;
+    projectName: string;
+
+    cloneUrl: string;
+    branch: string;
+
+    startedAt: string;
+    startedBy: string;
+    startedByAvatar?: string;
+
+    changeTitle: string;
+    changeDate: string;
+    changeAuthor: string;
+    changeAuthorAvatar?: string;
+    changePR?: string;
+    changeUrl?: string;
+    changeHash: string;
+}
+export namespace PrebuildInfo {
+    export function is(data?: any): data is PrebuildInfo {
+        return typeof data === "object" && ["id", "buildWorkspaceId", "projectId", "branch"].every(p => p in data);
+    }
+}
+
+export interface StartPrebuildResult {
+    prebuildId: string;
+    wsid: string;
+    done: boolean;
+}
+
+export interface Team {
+    id: string;
+    name: string;
+    slug: string;
+    creationTime: string;
+    markedDeleted?: boolean;
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}
+
+export type TeamMemberRole = "owner" | "member";
+
+export interface TeamMemberInfo {
+    userId: string;
+    fullName?: string;
+    primaryEmail?: string;
+    avatarUrl?: string;
+    role: TeamMemberRole;
+    memberSince: string;
+}
+
+export interface TeamMembershipInvite {
+    id: string;
+    teamId: string;
+    role: TeamMemberRole;
+    creationTime: string;
+    invalidationTime: string;
+    invitedEmail?: string;
+
+    /** This is a flag that triggers the HARD DELETION of this entity */
+    deleted?: boolean;
+}

package/src/util/analytics.ts

@@ -5,30 +5,9 @@
  */
 
 import Analytics = require("analytics-node");
+import { IAnalyticsWriter, IdentifyMessage, TrackMessage, PageMessage } from "../analytics";
 import { log } from './logging';
 
-export const IAnalyticsWriter = Symbol("IAnalyticsWriter");
-
-type Identity =
-    | { userId: string | number }
-    | { userId?: string | number; anonymousId: string | number };
-
-interface Message {
-    messageId?: string;
-}
-
-export type IdentifyMessage = Message & Identity & {
-    traits?: any;
-    timestamp?: Date;
-    context?: any;
-};
-
-export type TrackMessage = Message & Identity & {
-    event: string;
-    properties?: any;
-    timestamp?: Date;
-    context?: any;
-};
 
 export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
     switch (process.env.GITPOD_ANALYTICS_WRITER) {
@@ -41,14 +20,6 @@ export function newAnalyticsWriterFromEnv(): IAnalyticsWriter {
     }
 }
 
-export interface IAnalyticsWriter {
-
-    identify(msg: IdentifyMessage): void;
-
-    track(msg: TrackMessage): void;
-
-}
-
 class SegmentAnalyticsWriter implements IAnalyticsWriter {
 
     protected readonly analytics: Analytics;
@@ -81,6 +52,18 @@ class SegmentAnalyticsWriter implements IAnalyticsWriter {
         }
     }
 
+    page(msg: PageMessage) {
+        try{
+            this.analytics.page(msg, (err: Error) => {
+                if (err) {
+                    log.warn("analytics.page failed", err);
+                }
+            });
+        } catch (err) {
+            log.warn("analytics.page failed", err);
+        }
+    }
+
 }
 
 class LogAnalyticsWriter implements IAnalyticsWriter {
@@ -91,10 +74,14 @@ class LogAnalyticsWriter implements IAnalyticsWriter {
     track(msg: TrackMessage): void {
         log.debug("analytics track", msg);
     }
+    page(msg: PageMessage): void {
+        log.debug("analytics page", msg);
+    }
 
 }
 
 class NoAnalyticsWriter implements IAnalyticsWriter {
     identify(msg: IdentifyMessage): void {}
     track(msg: TrackMessage): void {}
+    page(msg: PageMessage): void {}
 }

package/src/util/generate-workspace-id.ts

@@ -173,6 +173,7 @@ export const colors = [
     'deer',
     'dingo',
     'dinosaur',
+    'dodo',
     'dog',
     'dolphin',
     'donkey',

package/src/util/gitpod-cookie.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 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 * as cookie from 'cookie';
+
+
+/**
+ * This cookie indicates whether the connected client is a Gitpod user (= "has logged in within the last year") or not.
+ * This is used by "gitpod.io" and "www.gitpod.io" to display different content/buttons.
+ */
+export const NAME = "gitpod-user";
+export const VALUE = "true";
+
+/**
+ * @param domain The domain the Gitpod installation is installed onto
+ * @returns
+ */
+export function options(domain: string): cookie.CookieSerializeOptions {
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies
+    return {
+        path: "/",                          // make sure we send the cookie to all sub-pages
+        httpOnly: false,
+        secure: false,
+        maxAge: 60 * 60 * 24 * 365,         // 1 year
+        sameSite: "lax",                    // default: true. "Lax" needed to ensure we see cookies from users that neavigate to gitpod.io from external sites
+        domain: `.${domain}`,               // explicilty include subdomains to not only cover "gitpod.io", but also "www.gitpod.io" or workspaces
+    };
+};
+
+export function generateCookie(domain: string): string {
+    return cookie.serialize(NAME, VALUE, options(domain));
+};
+
+export function isPresent(cookies: string): boolean {
+    // needs to match the old (gitpod-user=loggedIn) and new (gitpod-user=true) values to ensure a smooth transition during rollout.
+    return !!cookies.match(`${NAME}=`);
+};

package/src/util/gitpod-host-url.spec.ts

@@ -25,5 +25,25 @@ export class GitpodHostUrlTest {
     @test public async testWithoutWorkspacePrefix() {
         expect(GitpodHostUrl.fromWorkspaceUrl("https://3000-moccasin-ferret-155799b3.ws-eu02.gitpod-staging.com/").withoutWorkspacePrefix().toString()).to.equal("https://gitpod-staging.com/");
     }
+
+    @test public async testWithoutWorkspacePrefix2() {
+        expect(GitpodHostUrl.fromWorkspaceUrl("https://gitpod-staging.com/").withoutWorkspacePrefix().toString()).to.equal("https://gitpod-staging.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix3() {
+        expect(GitpodHostUrl.fromWorkspaceUrl("https://gray-rook-5523v5d8.ws-dev.my-branch-1234.staging.gitpod-dev.com/").withoutWorkspacePrefix().toString()).to.equal("https://my-branch-1234.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix4() {
+        expect(GitpodHostUrl.fromWorkspaceUrl("https://my-branch-1234.staging.gitpod-dev.com/").withoutWorkspacePrefix().toString()).to.equal("https://my-branch-1234.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix5() {
+        expect(GitpodHostUrl.fromWorkspaceUrl("https://abc-nice-brunch-4224.staging.gitpod-dev.com/").withoutWorkspacePrefix().toString()).to.equal("https://abc-nice-brunch-4224.staging.gitpod-dev.com/");
+    }
+
+    @test public async testWithoutWorkspacePrefix6() {
+        expect(GitpodHostUrl.fromWorkspaceUrl("https://gray-rook-5523v5d8.ws-dev.abc-nice-brunch-4224.staging.gitpod-dev.com/").withoutWorkspacePrefix().toString()).to.equal("https://abc-nice-brunch-4224.staging.gitpod-dev.com/");
+    }
 }
 module.exports = new GitpodHostUrlTest()

package/src/util/gitpod-host-url.ts

@@ -18,7 +18,7 @@ const basewoWkspaceIDRegex = "(([a-f][0-9a-f]{7}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f
 const workspaceIDRegex = RegExp(`^${basewoWkspaceIDRegex}$`);
 
 // this pattern matches URL prefixes of workspaces
-const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${basewoWkspaceIDRegex}\.`);
+const workspaceUrlPrefixRegex = RegExp(`^([0-9]{4,6}-)?${basewoWkspaceIDRegex}\\.`);
 
 export class GitpodHostUrl {
     readonly url: URL;

package/src/util/grpc.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021 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.
+ */
+
+ export const defaultGRPCOptions = {
+    "grpc.keepalive_timeout_ms": 10000,
+    "grpc.keepalive_time_ms": 60000,
+    "grpc.http2.min_time_between_pings_ms": 10000,
+    "grpc.keepalive_permit_without_calls": 1,
+    "grpc-node.max_session_memory": 50,
+    "grpc.max_reconnect_backoff_ms": 5000,
+    "grpc.max_receive_message_length": 1024 * 1024 * 16,
+};

package/src/util/logging.ts

@@ -97,10 +97,14 @@ export namespace log {
     /**
      * Do not use in frontend.
      */
-    export function enableJSONLogging(componentArg: string, versionArg: string | undefined): void {
+    export function enableJSONLogging(componentArg: string, versionArg: string | undefined, logLevel?: LogrusLogLevel): void {
         component = componentArg;
         version = versionArg;
 
+        setLogLevel(logLevel);
+    }
+
+    export function setLogLevel(logLevel: LogrusLogLevel | undefined) {
         jsonLogging = true;
 
         console.error = function (...args: any[]): void {
@@ -115,8 +119,20 @@ export namespace log {
         console.debug = function (...args: any[]): void {
             debugLog(true, args);
         }
+
         console.log = console.info;
         // FIXME wrap also other console methods (e.g. trace())
+
+        // set/unset log functions based on loglevel so we only have to evaluate once, not every call
+        const noop = () => {};
+        const setLog = (logFunc: DoLogFunction, funcLevel: LogrusLogLevel): DoLogFunction => {
+            return LogrusLogLevel.isGreatherOrEqual(funcLevel, logLevel) ? logFunc : noop;
+        };
+
+        errorLog = setLog(doErrorLog, "error");
+        warnLog = setLog(doWarnLog, "warning");
+        infoLog = setLog(doInfoLog, "info");
+        debugLog = setLog(doDebugLog, "debug");
     }
 
     export function resetToDefaultLogging(): void {
@@ -128,24 +144,73 @@ export namespace log {
         console.info = infoConsoleLog;
         console.debug = debugConsoleLog;
     }
+
+    export function setVersion(versionArg: string) {
+        version = versionArg;
+    }
 }
 
-function errorLog(calledViaConsole: boolean, args: any[]): void {
+type DoLogFunction = (calledViaConsole: boolean, args: any[]) => void;
+
+let errorLog = doErrorLog;
+function doErrorLog(calledViaConsole: boolean, args: any[]): void {
     doLog(calledViaConsole, errorConsoleLog, 'ERROR', args);
 }
 
-function warnLog(calledViaConsole: boolean, args: any[]): void {
+let warnLog = doWarnLog;
+function doWarnLog(calledViaConsole: boolean, args: any[]): void {
     doLog(calledViaConsole, warnConsoleLog, 'WARNING', args);
 }
 
-function infoLog(calledViaConsole: boolean, args: any[]): void {
+let infoLog = doInfoLog;
+function doInfoLog(calledViaConsole: boolean, args: any[]): void {
     doLog(calledViaConsole, infoConsoleLog, 'INFO', args);
 }
 
-function debugLog(calledViaConsole: boolean, args: any[]): void {
+let debugLog = doDebugLog;
+function doDebugLog(calledViaConsole: boolean, args: any[]): void {
     doLog(calledViaConsole, debugConsoleLog, 'DEBUG', args);
 }
 
+// Ref: https://github.com/sirupsen/logrus#level-logging
+export type LogrusLogLevel = keyof (typeof LogrusLogLevels);
+export const LogrusLogLevels = {
+    trace: true,
+    debug: true,
+    info: true,
+    warning: true,
+    error: true,
+    fatal: true,
+    panic: true,
+}
+export namespace LogrusLogLevel {
+    export function isGreatherOrEqual(lvl: LogrusLogLevel | undefined, ref: LogrusLogLevel | undefined): boolean {
+        if (lvl === undefined) {
+            return false;
+        }
+        if (ref === undefined) {
+            return true;
+        }
+        return getLevelArity(lvl) >= getLevelArity(ref);
+    }
+    function getLevelArity(lvl: LogrusLogLevel): number {
+        return Object.keys(LogrusLogLevels)
+            .findIndex((l) => l === lvl);
+    }
+    export function getFromEnv(): LogrusLogLevel | undefined {
+        const lvlStr = process.env.LOG_LEVEL;
+        if (!lvlStr) {
+            return undefined;
+        }
+        const lvl = lvlStr as LogrusLogLevel;
+        const exists = LogrusLogLevels[lvl]
+        if (!exists) {
+            return undefined;
+        }
+        return lvl;
+    }
+}
+
 // Source: https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
 type GoogleLogSeverity = 'EMERGENCY' | 'ALERT' | 'CRITICAL' | 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
 namespace GoogleLogSeverity {
@@ -243,7 +308,6 @@ function makeLogItem(severity: GoogleLogSeverity, context: LogContext | undefine
         severity,
         time: new Date().toISOString(),
         environment: process.env.KUBE_STAGE,
-        region: process.env.GITPOD_REGION,
         context,
         message,
         error,

package/src/util/parse-workspace-id.spec.ts

@@ -6,7 +6,7 @@
 
 import * as chai from 'chai';
 import { suite, test } from 'mocha-typescript';
-import { parseWorkspaceIdFromHostname } from './parse-workspace-id';
+import { matchesInstanceIdOrLegacyWorkspaceIdExactly, matchesNewWorkspaceIdExactly, parseWorkspaceIdFromHostname } from './parse-workspace-id';
 const expect = chai.expect;
 
 @suite
@@ -52,5 +52,25 @@ export class ParseWorkspaceIdTest {
         const actual = parseWorkspaceIdFromHostname("webview-3000-ca81a50f-09d7-465c-acd9-264a747d5351.ws-eu01.some.subdomain.somehost.com");
         expect(actual).to.equal("ca81a50f-09d7-465c-acd9-264a747d5351");
     }
+
+    // match - instance ID
+    @test public matchesInstanceIdOrLegacyWorkspaceIdExactly_positive() {
+        const actual = matchesInstanceIdOrLegacyWorkspaceIdExactly("b7e0eaf8-ec73-44ec-81ea-04859263b656");
+        expect(actual).to.be.true;
+    }
+    @test public matchesInstanceIdOrLegacyWorkspaceIdExactly_negative() {
+        const actual = matchesInstanceIdOrLegacyWorkspaceIdExactly("b7e0eaf8-ec73-44ec-81a-04859263b656");
+        expect(actual).to.be.false;
+    }
+
+    // match - new workspace ID
+    @test public matchesWorkspaceIdExactly_new_positive() {
+        const actual = matchesNewWorkspaceIdExactly("moccasin-ferret-155799b3");
+        expect(actual).to.be.true;
+    }
+    @test public matchesWorkspaceIdExactly_new_negative() {
+        const actual = matchesNewWorkspaceIdExactly("moccasin-ferret-15599b3");
+        expect(actual).to.be.false;
+    }
 }
 module.exports = new ParseWorkspaceIdTest()

package/src/util/parse-workspace-id.ts

@@ -4,6 +4,14 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
+const REGEX_WORKSPACE_ID = /[0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8}/;
+const REGEX_WORKSPACE_ID_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID.source}$`);
+// We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
+const REGEX_WORKSPACE_ID_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID.source})\.ws`);
+
+const REGEX_WORKSPACE_ID_LEGACY = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_WORKSPACE_ID_LEGACY_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID_LEGACY.source}$`);
+const REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID_LEGACY.source})\.ws`);
 
 /**
  * Hostname may be of the form:
@@ -13,17 +21,35 @@
  * @param hostname The hostname the request is headed to
  */
 export const parseWorkspaceIdFromHostname = function(hostname: string) {
-    // We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
-    const wsIdExpression = /([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8})\.ws/g;
-    const match = wsIdExpression.exec(hostname);
+    const match = REGEX_WORKSPACE_ID_FROM_HOSTNAME.exec(hostname);
     if (match && match.length >= 2) {
         return match[1];
     } else {
-        const legacyUrlFormat = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.ws/g;
-        const legacyMatch = legacyUrlFormat.exec(hostname);
+        const legacyMatch = REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME.exec(hostname);
         if (legacyMatch && legacyMatch.length >= 2) {
             return legacyMatch[1];
         }
         return undefined;
     }
-}
+};
+
+/** Equalls UUIDv4 (and REGEX_WORKSPACE_ID_LEGACY!) */
+const REGEX_INSTANCE_ID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_INSTANCE_ID_EXACT = new RegExp(`^${REGEX_INSTANCE_ID.source}$`);
+
+/**
+ * @param maybeId
+ * @returns
+ */
+export const matchesInstanceIdOrLegacyWorkspaceIdExactly = function(maybeId: string): boolean {
+    return REGEX_INSTANCE_ID_EXACT.test(maybeId)
+        || REGEX_WORKSPACE_ID_LEGACY_EXACT.test(maybeId);
+};
+
+/**
+ * @param maybeWorkspaceId
+ * @returns
+ */
+export const matchesNewWorkspaceIdExactly = function(maybeWorkspaceId: string): boolean {
+    return REGEX_WORKSPACE_ID_EXACT.test(maybeWorkspaceId);
+};

package/src/workspace-cluster.ts

@@ -7,7 +7,6 @@
 import * as fs from 'fs';
 import { filePathTelepresenceAware } from './env';
 import { DeepPartial } from "./util/deep-partial";
-import { Without } from './util/without';
 import { PermissionName } from './permission';
 
 export interface WorkspaceCluster {
@@ -36,6 +35,9 @@ export interface WorkspaceCluster {
 
     // An optional set of constraints that limit who can start workspaces on the cluster
     admissionConstraints?: AdmissionConstraint[];
+
+    // An optional set of admission preferences that guide cluster selection
+    admissionPreferences?: AdmissionPreference[];
 }
 
 export type WorkspaceClusterState = "available" | "cordoned" | "draining";
@@ -50,12 +52,16 @@ export interface TLSConfig {
 export namespace TLSConfig {
     export const loadFromBase64File = (path: string): string => fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
 }
-export type WorkspaceClusterWoTLS = Without<WorkspaceCluster, "tls">;
+export type WorkspaceClusterWoTLS = Omit<WorkspaceCluster, "tls">;
 export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "url" | "tls">;
 
-export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole;
+export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole | AdmissionConstraintHasUserLevel;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
 export type AdmissionConstraintHasRole = { type: "has-permission", permission: PermissionName };
+export type AdmissionConstraintHasUserLevel = { type: "has-user-level", level: string };
+
+export type AdmissionPreference = AdmissionPreferenceUserLevel;
+export type AdmissionPreferenceUserLevel = { type: 'user-level', level: string };
 
 
 export const WorkspaceClusterDB = Symbol("WorkspaceClusterDB");

package/src/workspace-instance.ts

@@ -23,16 +23,22 @@ export interface WorkspaceInstance {
     // The time an instance has switched phase to 'Running'
     startedTime?: string;
 
+    // The time an instance has switched phase to 'Stopping' */
+    stoppingTime?: string;
+
     // The time an instance has switched phase to 'Stopped' */
     stoppedTime?: string;
 
     // ideUrl is the URL at which the workspace is available on the internet
+    // Note: this is nitially empty, filled during starting process!
     ideUrl: string;
 
     // region is the name of the workspace cluster this instance runs in
+    // Note: this is nitially empty, filled during starting process!
     region: string;
 
     // workspaceImage is the name of the Docker image this instance runs
+    // Note: this is nitially empty, filled during starting process!
     workspaceImage: string;
 
     // status is the latest status of the instance that we're aware of
@@ -83,7 +89,7 @@ export interface WorkspaceInstanceStatus {
 // WorkspaceInstancePhase describes a high-level state of a workspace instance
 export type WorkspaceInstancePhase =
     // unknown indicates an issue within the system in that it cannot determine the actual phase of
-	// a workspace. This phase is usually accompanied by an error.
+    // a workspace. This phase is usually accompanied by an error.
     "unknown" |
 
     // Preparing means that we haven't actually started the workspace instance just yet, but rather
@@ -91,21 +97,21 @@ export type WorkspaceInstancePhase =
     "preparing" |
 
     // Pending means the workspace does not yet consume resources in the cluster, but rather is looking for
-	// some space within the cluster. If for example the cluster needs to scale up to accomodate the
-	// workspace, the workspace will be in Pending state until that happened.
+    // some space within the cluster. If for example the cluster needs to scale up to accomodate the
+    // workspace, the workspace will be in Pending state until that happened.
     "pending" |
 
     // Creating means the workspace is currently being created. Thati includes downloading the images required
-	// to run the workspace over the network. The time spent in this phase varies widely and depends on the current
-	// network speed, image size and cache states.
+    // to run the workspace over the network. The time spent in this phase varies widely and depends on the current
+    // network speed, image size and cache states.
     "creating" |
 
     // Initializing is the phase in which the workspace is executing the appropriate workspace initializer (e.g. Git
-	// clone or backup download). After this phase one can expect the workspace to either be Running or Failed.
+    // clone or backup download). After this phase one can expect the workspace to either be Running or Failed.
     "initializing" |
 
     // Running means the workspace is able to actively perform work, either by serving a user through Theia,
-	// or as a headless workspace.
+    // or as a headless workspace.
     "running" |
 
     // Interrupted is an exceptional state where the container should be running but is temporarily unavailable.
@@ -139,6 +145,12 @@ export interface WorkspaceInstanceConditions {
 
     // ISO8601 timestamp when the first user activity was registered in the frontend. Only set if the workspace is running.
     firstUserActivity?: string;
+
+    // headless_task_failed indicates that a headless workspace task failed
+    headlessTaskFailed?: string;
+
+    // stopped_by_request is true if the workspace was stopped using a StopWorkspace call
+    stoppedByRequest?: boolean;
 }
 
 // AdmissionLevel describes who can access a workspace instance and its ports.

package/src/wsready.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-// generated using github.com/32leaves/bel on 2021-04-20 10:08:58.0197329 +0000 UTC m=+0.008313436
+// generated using github.com/32leaves/bel on 2021-08-03 10:42:32.582603295 +0000 UTC m=+0.005734479
 // DO NOT MODIFY
 
 export enum WorkspaceInitSource {

package/lib/util/context-url.d.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) 2020 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.
- */
-/**
- * The field "contextUrl" might contain prefixes like:
- *  - envvar1=value1/...
- *  - prebuild/...
- * This is the analogon to the (Prefix)ContextParser structure in "server".
- */
-export declare function contextUrlToUrl(contextUrl: string | undefined): URL | undefined;
-//# sourceMappingURL=context-url.d.ts.map

package/lib/util/context-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-url.d.ts","sourceRoot":"","sources":["../../src/util/context-url.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,GAAG,SAAS,CAU/E"}