@gitpod/gitpod-protocol 0.1.5-upgrade-code.5 → 0.1.5-vn-implement-jetbrains-terminals.0

package/src/accounting-protocol.ts

@@ -0,0 +1,229 @@
+/**
+ * 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 { v4 as uuidv4 } from 'uuid';
+import { User } from './protocol';
+import { oneMonthLater } from './util/timeutil';
+
+/*
+ * Subscription and acocunting data
+ */
+export interface AccountEntry {
+    uid: string;
+
+    userId: string;
+
+    /** [hours] */
+    amount: number;
+
+    /**
+     * credit: start of validity,
+     * session: end of (split-) session
+     */
+    date: string;
+
+    /**
+     * debits (session, expiry, loss): relation to credit
+     */
+    creditId?: string;
+
+    /**
+     * credit: end of validity
+     */
+    expiryDate?: string;         // exclusive
+
+    kind: AccountEntryKind;
+
+    /**
+     * credit: amount - accounted debits
+     * [hours]
+     */
+    remainingAmount?: number;
+
+    description?: object;
+}
+export namespace AccountEntry {
+    export function create<T extends AccountEntry>(entry: Omit<T, 'uid'>): T {
+        const result = entry as T;
+        result.uid = uuidv4();
+        return result;
+    };
+}
+
+export type DebitAccountEntryKind = 'session' | 'expiry' | 'loss';
+export type AccountEntryKind = 'credit' | DebitAccountEntryKind | 'carry' | 'open';
+
+export interface Credit extends AccountEntry {
+    kind: 'credit';
+    expiryDate: string;
+}
+export type Debit = LossDebit | ExpiryDebit | SessionDebit;
+export interface LossDebit extends AccountEntry {
+    kind: 'loss';
+}
+export interface ExpiryDebit extends AccountEntry {
+    kind: 'expiry';
+    creditId: undefined;
+}
+export interface SessionDebit extends AccountEntry {
+    kind: DebitAccountEntryKind;
+    creditId: string;
+}
+
+export type AccountEntryDescription = SessionDescription | CreditDescription;
+export interface CreditDescription {
+    subscriptionId: string;
+    planId: string;
+}
+export namespace CreditDescription {
+    export function is(obj: any): obj is CreditDescription {
+        return !!obj
+            && obj.hasOwnProperty('subscriptionId')
+            && obj.hasOwnProperty('planId');
+    }
+}
+export interface SessionDescription {
+    contextTitle: string;
+    contextUrl: string;
+    workspaceId: string;
+    workspaceInstanceId: string;
+}
+export namespace SessionDescription {
+    export function is(obj: any): obj is SessionDescription {
+        return !!obj
+            && obj.hasOwnProperty('contextTitle')
+            && obj.hasOwnProperty('contextUrl')
+            && obj.hasOwnProperty('workspaceId')
+            && obj.hasOwnProperty('workspaceInstanceId')
+    }
+}
+
+/**
+ * - The earliest subscription may start with User.creationDate
+ * - There may be multiple Gitpod subscriptions for a user at any given time
+ * - The dates form an interval of the form: [startDate, endDate)
+ * - Subscriptions that directly map to a Chargebee plan have their paymentReference set and MAY carry additional paymentData (UserPaidSubscription)
+ * - Subscriptions that are assigned to a user through a Team Subscription carry a teamSubscriptionSlotId (AssignedTeamSubscription)
+ */
+export interface Subscription {
+    uid: string;
+    userId: string;
+    startDate: string;           // inclusive
+    /** When the subscription will end (must be >= cancellationDate!) */
+    endDate?: string;            // exclusive
+    /** When the subscription was cancelled */
+    cancellationDate?: string;   // exclusive
+    /** Number of granted hours */
+    amount: number;
+    /** Number of granted hours for the first month: If this is set, use this value for the first month */
+    firstMonthAmount?: number;
+    planId?: string;
+    paymentReference?: string;
+    paymentData?: PaymentData;
+    teamSubscriptionSlotId?: string;
+    /** marks the subscription as deleted */
+    deleted?: boolean;
+}
+
+export interface SubscriptionAndUser extends Subscription {
+    user: User;
+}
+
+export interface PaymentData {
+    /** Marks the date as of which the _switch_ is effective. */
+    downgradeDate?: string;
+    /** Determines the new plan the dowgrade is targeted against (optional for backwards compatibility) */
+    newPlan?: string;
+}
+
+export interface UserPaidSubscription extends Subscription {
+    paymentReference: string;
+    paymentData?: PaymentData;
+}
+export namespace UserPaidSubscription {
+    export function is(data: any): data is UserPaidSubscription {
+        return !!data
+            && data.hasOwnProperty('paymentReference');
+    }
+}
+
+export interface AssignedTeamSubscription extends Subscription {
+    teamSubscriptionSlotId: string;
+}
+export namespace AssignedTeamSubscription {
+    export function is(data: any): data is AssignedTeamSubscription {
+        return !!data
+            && data.hasOwnProperty('teamSubscriptionSlotId');
+    }
+}
+
+export namespace Subscription {
+    export function create(newSubscription: Omit<Subscription, 'uid'>) {
+        const subscription = newSubscription as Subscription;
+        subscription.uid = uuidv4();
+        return subscription;
+    };
+    export function cancelSubscription(s: Subscription, cancellationDate: string, endDate?: string) {
+        s.endDate = endDate || cancellationDate;
+        s.cancellationDate = cancellationDate;
+    };
+    export function isSame(s1: Subscription | undefined, s2: Subscription | undefined): boolean {
+        return !!s1 && !!s2
+            && s1.userId === s2.userId
+            && s1.planId === s2.planId
+            && s1.startDate === s2.startDate
+            && s1.endDate === s2.endDate
+            && s1.amount === s2.amount
+            && s1.cancellationDate === s2.cancellationDate
+            && s1.deleted === s2.deleted
+            && ((s1.paymentData === undefined && s2.paymentData === undefined)
+                || (!!s1.paymentData && !!s2.paymentData
+                    && s1.paymentData.downgradeDate === s2.paymentData.downgradeDate
+                    && s1.paymentData.newPlan === s2.paymentData.newPlan));
+    };
+    export function isActive(s: Subscription, date: string): boolean {
+        return s.startDate <= date && (s.endDate === undefined || date < s.endDate);
+    };
+    export function isDowngraded(s: Subscription) {
+        return s.paymentData && s.paymentData.downgradeDate;
+    };
+    export function calculateCurrentPeriod(startDate: string, now: Date) {
+        let nextStartDate = startDate;
+        do {
+            startDate = nextStartDate;
+            nextStartDate = oneMonthLater(startDate, new Date(startDate).getDate());
+        } while (nextStartDate < now.toISOString());
+        return { startDate, endDate: nextStartDate };
+    };
+}
+
+export type MaybeSubscription = Subscription | undefined;
+
+export interface Period {
+    startDate: string;           // inclusive
+    endDate: string;             // exclusive
+}
+
+export type MaybePeriod = Period | undefined;
+
+export type AccountEntryFixedPeriod = Omit<AccountEntry, 'uid'> & { expiryDate: string };
+export interface AccountStatement extends Period {
+    userId: string;
+    /**
+     * The subscriptions that have not been cancelled yet at the end of the period
+     */
+    subscriptions: Subscription[];
+    credits: Credit[];
+    debits: Debit[];
+    /** Remaining valid hours (accumulated from credits) */
+    remainingHours: RemainingHours;
+}
+export type RemainingHours = number | 'unlimited';
+
+export interface CreditAlert {
+    userId: string,
+    remainingUsageHours: number
+}

package/src/admin-protocol.ts

@@ -5,22 +5,43 @@
  */
 
 import { User, Workspace, NamedWorkspaceFeatureFlag } from "./protocol";
-import { Without } from "./util/without";
+import { FindPrebuildsParams } from "./gitpod-service";
+import { PrebuildWithStatus } from "./teams-projects-protocol"
+import { Project, Team } from "./teams-projects-protocol";
 import { WorkspaceInstance, WorkspaceInstancePhase } from "./workspace-instance";
 import { RoleOrPermission } from "./permission";
+import { AccountStatement } from "./accounting-protocol";
+import { InstallationAdminSettings } from "./installation-admin-protocol";
 
 export interface AdminServer {
     adminGetUsers(req: AdminGetListRequest<User>): Promise<AdminGetListResult<User>>;
     adminGetUser(id: string): Promise<User>;
     adminBlockUser(req: AdminBlockUserRequest): Promise<User>;
+    adminDeleteUser(id: string): Promise<void>;
     adminModifyRoleOrPermission(req: AdminModifyRoleOrPermissionRequest): Promise<User>;
     adminModifyPermanentWorkspaceFeatureFlag(req: AdminModifyPermanentWorkspaceFeatureFlagRequest): Promise<User>;
 
+    adminGetTeamById(id: string): Promise<Team | undefined>;
+
     adminGetWorkspaces(req: AdminGetWorkspacesRequest): Promise<AdminGetListResult<WorkspaceAndInstance>>;
     adminGetWorkspace(id: string): Promise<WorkspaceAndInstance>;
     adminForceStopWorkspace(id: string): Promise<void>;
+    adminRestoreSoftDeletedWorkspace(id: string): Promise<void>;
+
+    adminGetProjectsBySearchTerm(req: AdminGetListRequest<Project>): Promise<AdminGetListResult<Project>>;
+    adminGetProjectById(id: string): Promise<Project | undefined>;
 
+    adminFindPrebuilds(params: FindPrebuildsParams): Promise<PrebuildWithStatus[]>;
     adminSetLicense(key: string): Promise<void>;
+
+    adminGetAccountStatement(userId: string): Promise<AccountStatement>;
+    adminSetProfessionalOpenSource(userId: string, shouldGetProfOSS: boolean): Promise<void>;
+    adminIsStudent(userId: string): Promise<boolean>;
+    adminAddStudentEmailDomain(userId: string, domain: string): Promise<void>;
+    adminGrantExtraHours(userId: string, extraHours: number): Promise<void>;
+
+    adminGetSettings(): Promise<InstallationAdminSettings>
+    adminUpdateSettings(settings: InstallationAdminSettings): Promise<void>
 }
 
 export interface AdminGetListRequest<T> {
@@ -57,7 +78,7 @@ export interface AdminModifyPermanentWorkspaceFeatureFlagRequest {
     }[]
 }
 
-export interface WorkspaceAndInstance extends Without<Workspace, "id"|"creationTime">, Without<WorkspaceInstance, "id"|"creationTime"> {
+export interface WorkspaceAndInstance extends Omit<Workspace, "id" | "creationTime">, Omit<WorkspaceInstance, "id" | "creationTime"> {
     workspaceId: string;
     workspaceCreationTime: string;
     instanceId: string;
@@ -65,6 +86,33 @@ export interface WorkspaceAndInstance extends Without<Workspace, "id"|"creationT
     phase: WorkspaceInstancePhase;
 }
 
-export interface AdminGetWorkspacesRequest extends AdminGetListRequest<WorkspaceAndInstance> {
-    ownerId?: string
-}
+export namespace WorkspaceAndInstance {
+    export function toWorkspace(wai: WorkspaceAndInstance): Workspace {
+        return {
+            id: wai.workspaceId,
+            creationTime: wai.workspaceCreationTime,
+            ...wai
+        };
+    }
+
+    export function toInstance(wai: WorkspaceAndInstance): WorkspaceInstance | undefined {
+        if (!wai.instanceId) {
+            return undefined;
+        }
+        return {
+            id: wai.instanceId,
+            creationTime: wai.instanceCreationTime,
+            ...wai
+        };
+    }
+}
+
+export type AdminGetWorkspacesRequest = AdminGetListRequest<WorkspaceAndInstance> & AdminGetWorkspacesQuery;
+/** The fields are meant to be used either OR (not combined) */
+export type AdminGetWorkspacesQuery = {
+    /** we use this field in case we have a UUIDv4 and don't know whether it's an (old) workspace or instance id */
+    instanceIdOrWorkspaceId?: string;
+    instanceId?: string;
+    workspaceId?: string;
+    ownerId?: string;
+};

package/src/analytics.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 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 type PageMessage = Message & Identity & {
+    properties?: any;
+    timestamp?: Date;
+    context?: any;
+};
+
+export type RemoteTrackMessage = Omit<TrackMessage, "timestamp" | "userId" | "anonymousId"> & {
+    anonymousId?: string | number;
+};
+export type RemotePageMessage = Omit<PageMessage, "timestamp" | "userId"> & {
+    anonymousId?: string | number;
+};
+
+export type RemoteIdentifyMessage = Omit<IdentifyMessage, "timestamp" | "userId" | "anonymousId">;
+
+export interface IAnalyticsWriter {
+
+    identify(msg: IdentifyMessage): void;
+
+    track(msg: TrackMessage): void;
+
+    page(msg: PageMessage): void;
+
+}

package/src/auth.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 interface SelectAccountPayload {
+    currentUser: {
+        name: string;
+        avatarUrl: string;
+        authHost: string;
+        authName: string;
+        authProviderType: string;
+    },
+    otherUser: {
+        name: string;
+        avatarUrl: string;
+        authHost: string;
+        authName: string;
+        authProviderType: string;
+    }
+}
+export namespace SelectAccountPayload {
+    export function is(data: any): data is SelectAccountPayload {
+        return typeof data === "object" && "currentUser" in data && "otherUser" in data;
+    }
+}

package/src/context-url.spec.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+import * as chai from 'chai';
+import { suite, test } from 'mocha-typescript';
+import { Workspace } from '.';
+import { ContextURL } from './context-url';
+const expect = chai.expect;
+
+type WsContextUrl = Pick<Workspace, "context" | "contextURL">;
+
+@suite
+export class ContextUrlTest {
+
+    @test public parseContextUrl_withEnvVar() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo", context: {} } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
+    }
+
+    @test public parseContextUrl_withEnvVar_withoutSchema() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "passedin=test%20value/github.com/gitpod-io/gitpod-test-repo", context: {} } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
+    }
+
+    @test public parseContextUrl_withEnvVar_sshUrl() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "passedin=test%20value/git@github.com:gitpod-io/gitpod-test-repo.git", context: {} } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo.git");
+    }
+
+    @test public parseContextUrl_withPrebuild() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "prebuild/https://github.com/gitpod-io/gitpod-test-repo", context: {} } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
+    }
+
+    @test public parseContextUrl_withPrebuild_withoutSchema() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "prebuild/github.com/gitpod-io/gitpod-test-repo", context: {} } as WsContextUrl);
+        expect(actual?.host).to.equal("github.com");
+        expect(actual?.pathname).to.equal("/gitpod-io/gitpod-test-repo");
+    }
+
+    @test public parseContextUrl_badUrl() {
+        const actual = ContextURL.getNormalizedURL({ contextURL: "[Object object]", context: {} } as WsContextUrl);
+        expect(actual).to.be.undefined;
+    }
+}
+module.exports = new ContextUrlTest()

package/src/context-url.ts

@@ -0,0 +1,107 @@
+/**
+ * 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.
+ */
+
+import { Workspace } from ".";
+
+/**
+ * The whole point of these methods is to overcome inconsistencies in our data model.
+ * Ideally we remove it at some point once we fixed our model, as it:
+ *  - duplicates logic
+ *  - but additional burden on clients (using this, copying this to other languages!)
+ *
+ * TODO(gpl) See if we can get this into `server` code to remove the burden from clients
+ */
+export namespace ContextURL {
+  export const INCREMENTAL_PREBUILD_PREFIX = "incremental-prebuild";
+  export const PREBUILD_PREFIX = "prebuild";
+  export const IMAGEBUILD_PREFIX = "imagebuild";
+  export const SNAPSHOT_PREFIX = "snapshot";
+  export const REFERRER_PREFIX = 'referrer:';
+
+  /**
+   * This function will (try to) return the HTTP(S) URL of the context the user originally created this workspace on.
+   * Especially it will not contain any modifiers or be of different scheme than HTTP(S).
+   *
+   * Use this function if you need to provided a _working_ URL to the original context.
+   * @param ws
+   * @returns
+   */
+  export function getNormalizedURL(ws: Pick<Workspace, "context" | "contextURL"> | undefined): URL | undefined {
+    const normalized = normalize(ws);
+    if (!normalized) {
+      return undefined;
+    }
+
+    try {
+      return new URL(normalized);
+    } catch (err) {
+      console.error(`unable to parse URL from normalized contextURL: '${normalized}'`, err);
+    }
+    return undefined;
+  }
+
+  function normalize(ws: Pick<Workspace, "context" | "contextURL"> | undefined): string | undefined {
+    if (!ws) {
+      return undefined;
+    }
+    if (ws.context.normalizedContextURL) {
+      return ws.context.normalizedContextURL;
+    }
+
+    // fallback: we do not yet set normalizedContextURL on all workspaces, yet, let alone older existing workspaces
+    let fallback: string | undefined = undefined;
+    try {
+      fallback = removePrefixes(ws.contextURL);
+    } catch (err) {
+      console.error(`unable to remove prefixes from contextURL: '${ws.contextURL}'`, err);
+    }
+    return fallback;
+  }
+
+  /**
+   * The field "contextUrl" might contain prefixes like:
+   *  - envvar1=value1/...
+   *  - prebuild/...
+   * This is the analogon to the (Prefix)ContextParser structure in "server".
+   */
+  function removePrefixes(contextUrl: string | undefined): string | undefined {
+    if (contextUrl === undefined) {
+      return undefined;
+    }
+
+    const segments = contextUrl.split("/");
+    if (segments.length === 1) {
+      return segments[0];  // this might be something, we just try
+    }
+
+    const segmentsToURL = (offset: number): string => {
+      let rest = segments.slice(offset).join("/");
+      if (/^git@[^:\/]+:/.test(rest)) {
+        rest = rest.replace(/^git@([^:\/]+):/, 'https://$1/');
+      }
+      if (!rest.startsWith("http")) {
+        rest = 'https://' + rest;
+      }
+      return rest;
+    };
+
+    const firstSegment = segments[0];
+    if (firstSegment === PREBUILD_PREFIX ||
+        firstSegment === INCREMENTAL_PREBUILD_PREFIX ||
+        firstSegment === IMAGEBUILD_PREFIX ||
+        firstSegment === SNAPSHOT_PREFIX ||
+        firstSegment.startsWith(REFERRER_PREFIX)) {
+      return segmentsToURL(1);
+    }
+
+    // check for env vars
+    if (firstSegment.indexOf("=") !== -1) {
+      return segmentsToURL(1);
+    }
+
+    return segmentsToURL(0);
+  }
+}

package/src/email-protocol.ts

@@ -4,8 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { Without } from "./util/without";
-import uuidv4 = require("uuid/v4");
+import { v4 as uuidv4 } from 'uuid';
 
 export type EMailState = "scheduledInternal"
     | "scheduledSendgrid";
@@ -59,7 +58,7 @@ export type EMail = {
 } & EMailStatus;
 
 export namespace EMail {
-    export const create = (ts: Without<EMail, 'uid'>): EMail => {
+    export const create = (ts: Omit<EMail, 'uid'>): EMail => {
         const withId = ts as EMail;
         withId.uid = uuidv4();
         return withId;

package/src/env.ts

@@ -13,18 +13,18 @@ const legacyStagenameTranslation: { [key: string]: KubeStage } = {
     "dev": "dev"
 }
 
+export function translateLegacyStagename(kubeStage: string): KubeStage {
+    const stage = legacyStagenameTranslation[kubeStage];
+    if (!stage) {
+        throw new Error(`Invalid KUBE_STAGE: ${kubeStage}`);
+    }
+
+    return stage;
+}
+
 @injectable()
 export abstract class AbstractComponentEnv {
-    readonly kubeStage: KubeStage = getEnvVarParsed('KUBE_STAGE', (kubeStage) => {
-        const stage = legacyStagenameTranslation[kubeStage];
-        if (!stage) {
-            throw new Error(`Environment variable invalid: KUBE_STAGE=${kubeStage}`);
-        }
-
-        return stage;
-    });
-    readonly kubeNamespace: string = getEnvVar('KUBE_NAMESPACE');
-    readonly version: string = getEnvVar('VERSION');
+    readonly kubeStage: KubeStage = getEnvVarParsed('KUBE_STAGE', translateLegacyStagename);
 
     readonly installationLongname: string = getEnvVar("GITPOD_INSTALLATION_LONGNAME")
     readonly installationShortname: string = getEnvVar("GITPOD_INSTALLATION_SHORTNAME")