@gitpod/gitpod-protocol 0.1.5-vn-update-gitpod-json-schema.0 → 0.1.5-vn-jetbrains-backend-plugin-223.6

package/src/protocol.ts

@@ -8,6 +8,7 @@ import { WorkspaceInstance, PortVisibility } from "./workspace-instance";
 import { RoleOrPermission } from "./permission";
 import { Project } from "./teams-projects-protocol";
 import { createHash } from "crypto";
+import { AttributionId } from "./attribution";
 
 export interface UserInfo {
     name?: string;
@@ -45,6 +46,15 @@ export interface User {
     markedDeleted?: boolean;
 
     additionalData?: AdditionalUserData;
+
+    // Identifies an explicit team or user ID to which all the user's workspace usage should be attributed to (e.g. for billing purposes)
+    usageAttributionId?: string;
+
+    // The last time this user got verified somehow. The user is not verified if this is empty.
+    lastVerificationTime?: string;
+
+    // The phone number used for the last phone verification.
+    verificationPhoneNumber?: string;
 }
 
 export namespace User {
@@ -70,11 +80,14 @@ export namespace User {
     }
 
     /**
-     * Tries to return the primaryEmail of the first identity this user signed up with.
+     * Returns the stored email or if it doesn't exist returns the primaryEmail of the first identity this user signed up with.
      * @param user
      * @returns A primaryEmail, or undefined if there is none.
      */
     export function getPrimaryEmail(user: User): string | undefined {
+        if (user.additionalData?.profile?.emailAddress) {
+            return user.additionalData?.profile?.emailAddress;
+        }
         const identities = user.identities.filter((i) => !!i.primaryEmail);
         if (identities.length <= 0) {
             return undefined;
@@ -136,6 +149,50 @@ export namespace User {
         }
         user.additionalData.ideSettings = newIDESettings;
     }
+
+    export function getProfile(user: User): Profile {
+        return {
+            name: User.getName(user!) || "",
+            email: User.getPrimaryEmail(user!) || "",
+            company: user?.additionalData?.profile?.companyName,
+            avatarURL: user?.avatarUrl,
+        };
+    }
+
+    export function setProfile(user: User, profile: Profile): User {
+        user.fullName = profile.name;
+        user.avatarUrl = profile.avatarURL;
+
+        if (!user.additionalData) {
+            user.additionalData = {};
+        }
+        if (!user.additionalData.profile) {
+            user.additionalData.profile = {};
+        }
+        user.additionalData.profile.emailAddress = profile.email;
+        user.additionalData.profile.companyName = profile.company;
+        user.additionalData.profile.lastUpdatedDetailsNudge = new Date().toISOString();
+
+        return user;
+    }
+
+    // The actual Profile of a User
+    export interface Profile {
+        name: string;
+        email: string;
+        company?: string;
+        avatarURL?: string;
+    }
+    export namespace Profile {
+        export function hasChanges(before: Profile, after: Profile) {
+            return (
+                before.name !== after.name ||
+                before.email !== after.email ||
+                before.company !== after.company ||
+                before.avatarURL !== after.avatarURL
+            );
+        }
+    }
 }
 
 export interface AdditionalUserData {
@@ -150,9 +207,36 @@ export interface AdditionalUserData {
     oauthClientsApproved?: { [key: string]: string };
     // to remember GH Orgs the user installed/updated the GH App for
     knownGitHubOrgs?: string[];
-
     // Git clone URL pointing to the user's dotfile repo
     dotfileRepo?: string;
+    // preferred workspace classes
+    workspaceClasses?: WorkspaceClasses;
+    // additional user profile data
+    profile?: ProfileDetails;
+}
+export namespace AdditionalUserData {
+    export function set(user: User, partialData: Partial<AdditionalUserData>): User {
+        if (!user.additionalData) {
+            user.additionalData = {
+                ...partialData,
+            };
+        } else {
+            user.additionalData = {
+                ...user.additionalData,
+                ...partialData,
+            };
+        }
+        return user;
+    }
+}
+// The format in which we store User Profiles in
+export interface ProfileDetails {
+    // when was the last time the user updated their profile information or has been nudged to do so.
+    lastUpdatedDetailsNudge?: string;
+    // the user's company name
+    companyName?: string;
+    // the user's email
+    emailAddress?: string;
 }
 
 export interface EmailNotificationSettings {
@@ -171,6 +255,11 @@ export type IDESettings = {
     useLatestVersion?: boolean;
 };
 
+export interface WorkspaceClasses {
+    regular: string;
+    prebuild: string;
+}
+
 export interface UserPlatform {
     uid: string;
     userAgent: string;
@@ -197,16 +286,29 @@ export interface UserFeatureSettings {
     permanentWSFeatureFlags?: NamedWorkspaceFeatureFlag[];
 }
 
+export type BillingTier = "paid" | "free";
+
 /**
  * The values of this type MUST MATCH enum values in WorkspaceFeatureFlag from ws-manager/client/core_pb.d.ts
  * If they don't we'll break things during workspace startup.
  */
 export const WorkspaceFeatureFlags = {
     full_workspace_backup: undefined,
-    fixed_resources: undefined,
     persistent_volume_claim: undefined,
+    protected_secrets: undefined,
+    workspace_class_limiting: undefined,
+    workspace_connection_limiting: undefined,
 };
 export type NamedWorkspaceFeatureFlag = keyof typeof WorkspaceFeatureFlags;
+export namespace NamedWorkspaceFeatureFlag {
+    export const WORKSPACE_PERSISTED_FEATTURE_FLAGS: NamedWorkspaceFeatureFlag[] = [
+        "full_workspace_backup",
+        "persistent_volume_claim",
+    ];
+    export function isWorkspacePersisted(ff: NamedWorkspaceFeatureFlag): boolean {
+        return WORKSPACE_PERSISTED_FEATTURE_FLAGS.includes(ff);
+    }
+}
 
 export interface EnvVarWithValue {
     name: string;
@@ -243,7 +345,7 @@ export namespace UserEnvVar {
             return "Name must not be empty.";
         }
         if (name.length > 255) {
-            return 'Name too long. Maximum name length is 255 characters.';
+            return "Name too long. Maximum name length is 255 characters.";
         }
         if (!/^[a-zA-Z_]+[a-zA-Z0-9_]*$/.test(name)) {
             return "Name must match /^[a-zA-Z_]+[a-zA-Z0-9_]*$/.";
@@ -252,7 +354,7 @@ export namespace UserEnvVar {
             return "Value must not be empty.";
         }
         if (variable.value.length > 32767) {
-            return 'Value too long. Maximum value length is 32767 characters.';
+            return "Value too long. Maximum value length is 32767 characters.";
         }
         if (pattern.trim() === "") {
             return "Scope must not be empty.";
@@ -356,6 +458,68 @@ export namespace UserEnvVar {
     }
 }
 
+export interface SSHPublicKeyValue {
+    name: string;
+    key: string;
+}
+export interface UserSSHPublicKey extends SSHPublicKeyValue {
+    id: string;
+    key: string;
+    userId: string;
+    fingerprint: string;
+    creationTime: string;
+    lastUsedTime?: string;
+}
+
+export type UserSSHPublicKeyValue = Omit<UserSSHPublicKey, "key" | "userId">;
+
+export namespace SSHPublicKeyValue {
+    export function validate(value: SSHPublicKeyValue): string | undefined {
+        if (value.name.length === 0) {
+            return "Title must not be empty.";
+        }
+        if (value.name.length > 255) {
+            return "Title too long. Maximum value length is 255 characters.";
+        }
+        if (value.key.length === 0) {
+            return "Key must not be empty.";
+        }
+        try {
+            getData(value);
+        } catch (e) {
+            return "Key is invalid. You must supply a key in OpenSSH public key format.";
+        }
+        return;
+    }
+
+    export function getData(value: SSHPublicKeyValue) {
+        // Begins with 'ssh-rsa', 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521', 'ssh-ed25519', 'sk-ecdsa-sha2-nistp256@openssh.com', or 'sk-ssh-ed25519@openssh.com'.
+        const regex =
+            /^(?<type>ssh-rsa|ecdsa-sha2-nistp256|ecdsa-sha2-nistp384|ecdsa-sha2-nistp521|ssh-ed25519|sk-ecdsa-sha2-nistp256@openssh\.com|sk-ssh-ed25519@openssh\.com) (?<key>.*?)( (?<email>.*?))?$/;
+        const resultGroup = regex.exec(value.key.trim());
+        if (!resultGroup) {
+            throw new Error("Key is invalid.");
+        }
+        return {
+            type: resultGroup.groups?.["type"] as string,
+            key: resultGroup.groups?.["key"] as string,
+            email: resultGroup.groups?.["email"] || undefined,
+        };
+    }
+
+    export function getFingerprint(value: SSHPublicKeyValue) {
+        const data = getData(value);
+        let buf = Buffer.from(data.key, "base64");
+        // gitlab style
+        // const hash = createHash("md5").update(buf).digest("hex");
+        // github style
+        const hash = createHash("sha256").update(buf).digest("base64");
+        return hash;
+    }
+
+    export const MAXIMUM_KEY_LENGTH = 5;
+}
+
 export interface GitpodToken {
     /** Hash value (SHA256) of the token (primary key). */
     tokenHash: string;
@@ -488,6 +652,13 @@ export interface Snapshot {
     message?: string;
 }
 
+export interface VolumeSnapshot {
+    id: string;
+    workspaceId: string;
+    creationTime: string;
+    volumeHandle: string;
+}
+
 export type SnapshotState = "pending" | "available" | "error";
 
 export interface LayoutData {
@@ -557,7 +728,7 @@ export interface Workspace {
 
 export type WorkspaceSoftDeletion = "user" | "gc";
 
-export type WorkspaceType = "regular" | "prebuild" | "probe";
+export type WorkspaceType = "regular" | "prebuild";
 
 export namespace Workspace {
     export function getFullRepositoryName(ws: Workspace): string | undefined {
@@ -633,6 +804,7 @@ export interface JetBrainsConfig {
 }
 export interface JetBrainsProductConfig {
     prebuilds?: JetBrainsPrebuilds;
+    vmoptions?: string;
 }
 export interface JetBrainsPrebuilds {
     version?: "stable" | "latest" | "both";
@@ -643,6 +815,12 @@ export interface RepositoryCloneInformation {
     checkoutLocation?: string;
 }
 
+export interface CoreDumpConfig {
+    enabled?: boolean;
+    softLimit?: number;
+    hardLimit?: number;
+}
+
 export interface WorkspaceConfig {
     mainConfiguration?: string;
     additionalRepositories?: RepositoryCloneInformation[];
@@ -655,6 +833,7 @@ export interface WorkspaceConfig {
     github?: GithubAppConfig;
     vscode?: VSCodeConfig;
     jetbrains?: JetBrainsConfig;
+    coreDump?: CoreDumpConfig;
 
     /** deprecated. Enabled by default **/
     experimentalNetwork?: boolean;
@@ -663,13 +842,12 @@ export interface WorkspaceConfig {
      * Where the config object originates from.
      *
      * repo - from the repository
-     * project-db - from the "Project" stored in the database
      * definitly-gp - from github.com/gitpod-io/definitely-gp
      * derived - computed based on analyzing the repository
      * additional-content - config comes from additional content, usually provided through the project's configuration
      * default - our static catch-all default config
      */
-    _origin?: "repo" | "project-db" | "definitely-gp" | "derived" | "additional-content" | "default";
+    _origin?: "repo" | "definitely-gp" | "derived" | "additional-content" | "default";
 
     /**
      * Set of automatically infered feature flags. That's not something the user can set, but
@@ -748,7 +926,9 @@ export interface PrebuiltWorkspace {
 
 export namespace PrebuiltWorkspace {
     export function isDone(pws: PrebuiltWorkspace) {
-        return pws.state === "available" || pws.state === "timeout" || pws.state === "aborted";
+        return (
+            pws.state === "available" || pws.state === "timeout" || pws.state === "aborted" || pws.state === "failed"
+        );
     }
 
     export function isAvailable(pws: PrebuiltWorkspace) {
@@ -872,6 +1052,7 @@ export namespace ExternalImageConfigFile {
 
 export interface WorkspaceContext {
     title: string;
+    ref?: string;
     /** This contains the URL portion of the contextURL (which might contain other modifiers as well). It's optional because it's not set for older workspaces. */
     normalizedContextURL?: string;
     forceCreateNewWorkspace?: boolean;
@@ -984,17 +1165,6 @@ export namespace WithEnvvarsContext {
     }
 }
 
-export interface WorkspaceProbeContext extends WorkspaceContext {
-    responseURL: string;
-    responseToken: string;
-}
-
-export namespace WorkspaceProbeContext {
-    export function is(context: any): context is WorkspaceProbeContext {
-        return context && "responseURL" in context && "responseToken" in context;
-    }
-}
-
 export type RefType = "branch" | "tag" | "revision";
 export namespace RefType {
     export const getRefType = (commit: Commit): RefType => {
@@ -1340,3 +1510,18 @@ export interface Terms {
     readonly content: string;
     readonly formElements?: object;
 }
+
+export interface StripeConfig {
+    individualUsagePriceIds: { [currency: string]: string };
+    teamUsagePriceIds: { [currency: string]: string };
+}
+
+export type BillingStrategy = "other" | "stripe";
+export interface CostCenter {
+    readonly id: AttributionId;
+    /**
+     * Unit: credits
+     */
+    spendingLimit: number;
+    billingStrategy: BillingStrategy;
+}

package/src/team-subscription-protocol.ts

@@ -33,6 +33,33 @@ export namespace TeamSubscription {
     };
 }
 
+export interface TeamSubscription2 {
+    id: string;
+    teamId: string;
+    planId: string;
+    startDate: string;
+    endDate?: string;
+    quantity: number;
+    /** The Chargebee subscription id */
+    paymentReference: string;
+    cancellationDate?: string;
+    excludeFromMoreResources: boolean;
+}
+
+export namespace TeamSubscription2 {
+    export const create = (ts2: Omit<TeamSubscription2, "id">): TeamSubscription2 => {
+        const withId = ts2 as TeamSubscription2;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
+        return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
+    };
+    export function isCancelled(s: TeamSubscription2, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
+    }
+}
+
 /**
  * A slot represents one unit of a TeamSubscription that gets assigned to one user at a time
  */

package/src/teams-projects-protocol.ts

@@ -7,6 +7,7 @@
 import { PrebuiltWorkspaceState } from "./protocol";
 import { v4 as uuidv4 } from "uuid";
 import { DeepPartial } from "./util/deep-partial";
+import { WebhookEvent } from "./webhook-event";
 
 export interface ProjectConfig {
     ".gitpod.yml": string;
@@ -14,6 +15,8 @@ export interface ProjectConfig {
 
 export interface ProjectSettings {
     useIncrementalPrebuilds?: boolean;
+    usePersistentVolumeClaim?: boolean;
+    keepOutdatedPrebuildsRunning?: boolean;
 }
 
 export interface Project {
@@ -24,7 +27,6 @@ export interface Project {
     teamId?: string;
     userId?: string;
     appInstallationId: string;
-    config?: ProjectConfig;
     settings?: ProjectSettings;
     creationTime: string;
     /** This is a flag that triggers the HARD DELETION of this entity */
@@ -150,3 +152,15 @@ export interface TeamMembershipInvite {
     /** This is a flag that triggers the HARD DELETION of this entity */
     deleted?: boolean;
 }
+
+export interface PrebuildEvent {
+    id: string;
+    creationTime: string;
+    status: WebhookEvent.Status | WebhookEvent.PrebuildStatus;
+    message?: string;
+    prebuildId?: string;
+    projectId?: string;
+    cloneUrl?: string;
+    branch?: string;
+    commit?: string;
+}

package/src/usage.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { WorkspaceType } from "./protocol";
+
+// types below are copied over from components/usage-api/typescript/src/usage/v1/usage_pb.d.ts
+export interface ListUsageRequest {
+    attributionId: string;
+    from?: number;
+    to?: number;
+    order: Ordering;
+    pagination?: PaginationRequest;
+}
+
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
+
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
+
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditsUsed: number;
+}
+
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
+}
+
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
+    attributionId: string;
+    description: string;
+    credits: number;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
+}
+
+// the equivalent golang shape is maintained in `/workspace/gitpod/`components/usage/pkg/db/usage.go`
+export interface WorkspaceInstanceUsageData {
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+    workspaceClass: string;
+    contextURL: string;
+    startTime: string;
+    endTime?: string;
+    userId: string;
+    userName: string;
+    userAvatarURL: string;
+}
+
+export interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
+}

package/src/util/debug-app.ts

@@ -0,0 +1,81 @@
+/**
+ * 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 http from "http";
+import * as express from "express";
+import { injectable, postConstruct } from "inversify";
+import { log, LogrusLogLevel } from "./logging";
+
+export interface SetLogLevelRequest {
+    level: LogrusLogLevel;
+}
+export namespace SetLogLevelRequest {
+    export function is(o: any): o is SetLogLevelRequest {
+        return typeof o === "object" && "level" in o;
+    }
+}
+
+@injectable()
+export class DebugApp {
+    protected _app: express.Application;
+    protected httpServer: http.Server | undefined = undefined;
+
+    @postConstruct()
+    public ctor() {
+        this._app = this.create();
+    }
+
+    create(): express.Application {
+        const app = express();
+
+        app.use(express.json());
+        app.use(express.urlencoded({ extended: true }));
+
+        app.post("/debug/logging", (req, res) => {
+            try {
+                const levelRequest = req.body;
+                if (!SetLogLevelRequest.is(levelRequest)) {
+                    res.status(400).end("not a SetLogLevelRequest");
+                    return;
+                }
+
+                const newLogLevel = levelRequest.level;
+                log.setLogLevel(newLogLevel);
+                log.info("set log level", { newLogLevel });
+                res.status(200).end(JSON.stringify(levelRequest));
+            } catch (err) {
+                res.status(500).end(err);
+            }
+        });
+        return app;
+    }
+
+    public start(port: number = 6060) {
+        this.httpServer = this._app.listen(port, "localhost", () => {
+            log.info(`debug server listening on port: ${port}`);
+        });
+    }
+
+    public async stop() {
+        const server = this.httpServer;
+        if (!server) {
+            return;
+        }
+        return new Promise<void>((resolve) =>
+            server.close((err: any) => {
+                if (err) {
+                    log.warn(`error while closing http server`, { err });
+                }
+                this.httpServer = undefined;
+                resolve();
+            }),
+        );
+    }
+
+    public get app(): express.Application {
+        return this._app;
+    }
+}

package/src/util/garbage-collected-cache.ts

@@ -37,6 +37,11 @@ export class GarbageCollectedCache<T> {
         if (!entry) {
             return undefined;
         }
+        // Still valid?
+        if (entry.expiryDate < Date.now()) {
+            this.store.delete(entry.key);
+            return undefined;
+        }
         return entry.value;
     }
 

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

@@ -85,6 +85,10 @@ export class GitpodHostUrl {
         return this.with((url) => ({ protocol: url.protocol === "https:" ? "wss:" : "ws:" }));
     }
 
+    asWorkspacePage(): GitpodHostUrl {
+        return this.with((url) => ({ pathname: "/workspaces" }));
+    }
+
     asDashboard(): GitpodHostUrl {
         return this.with((url) => ({ pathname: "/" }));
     }
@@ -171,4 +175,21 @@ export class GitpodHostUrl {
     asApiLogout(): GitpodHostUrl {
         return this.withApi((url) => ({ pathname: "/logout/" }));
     }
+
+    asIDEProxy(): GitpodHostUrl {
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] === "ide") {
+            return this;
+        }
+        return this.with((url) => ({ host: "ide." + url.host }));
+    }
+
+    asIDEMetrics(): GitpodHostUrl {
+        let newUrl: GitpodHostUrl = this;
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] !== "ide") {
+            newUrl = newUrl.asIDEProxy();
+        }
+        return newUrl.with((url) => ({ pathname: "/metrics-api" }));
+    }
 }