@gitpod/gitpod-protocol 0.1.5-server-vscode-oauth2.11 → 0.1.5-server-vscode-oauth2.25

package/src/accounting-protocol.ts

@@ -4,9 +4,9 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
- import * as uuidv4 from 'uuid/v4';
-import { User } from './protocol';
-import { oneMonthLater } from './util/timeutil';
+import { v4 as uuidv4 } from "uuid";
+import { User } from "./protocol";
+import { oneMonthLater } from "./util/timeutil";
 
 /*
  * Subscription and acocunting data
@@ -33,7 +33,7 @@ export interface AccountEntry {
     /**
      * credit: end of validity
      */
-    expiryDate?: string;         // exclusive
+    expiryDate?: string; // exclusive
 
     kind: AccountEntryKind;
 
@@ -46,26 +46,26 @@ export interface AccountEntry {
     description?: object;
 }
 export namespace AccountEntry {
-    export function create<T extends AccountEntry>(entry: Omit<T, 'uid'>): T {
+    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 type DebitAccountEntryKind = "session" | "expiry" | "loss";
+export type AccountEntryKind = "credit" | DebitAccountEntryKind | "carry" | "open";
 
 export interface Credit extends AccountEntry {
-    kind: 'credit';
+    kind: "credit";
     expiryDate: string;
 }
 export type Debit = LossDebit | ExpiryDebit | SessionDebit;
 export interface LossDebit extends AccountEntry {
-    kind: 'loss';
+    kind: "loss";
 }
 export interface ExpiryDebit extends AccountEntry {
-    kind: 'expiry';
+    kind: "expiry";
     creditId: undefined;
 }
 export interface SessionDebit extends AccountEntry {
@@ -80,9 +80,7 @@ export interface CreditDescription {
 }
 export namespace CreditDescription {
     export function is(obj: any): obj is CreditDescription {
-        return !!obj
-            && obj.hasOwnProperty('subscriptionId')
-            && obj.hasOwnProperty('planId');
+        return !!obj && obj.hasOwnProperty("subscriptionId") && obj.hasOwnProperty("planId");
     }
 }
 export interface SessionDescription {
@@ -90,16 +88,16 @@ export interface SessionDescription {
     contextUrl: string;
     workspaceId: string;
     workspaceInstanceId: string;
-    private: boolean;
 }
 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')
-            && obj.hasOwnProperty('private');
+        return (
+            !!obj &&
+            obj.hasOwnProperty("contextTitle") &&
+            obj.hasOwnProperty("contextUrl") &&
+            obj.hasOwnProperty("workspaceId") &&
+            obj.hasOwnProperty("workspaceInstanceId")
+        );
     }
 }
 
@@ -113,11 +111,11 @@ export namespace SessionDescription {
 export interface Subscription {
     uid: string;
     userId: string;
-    startDate: string;           // inclusive
+    startDate: string; // inclusive
     /** When the subscription will end (must be >= cancellationDate!) */
-    endDate?: string;            // exclusive
+    endDate?: string; // exclusive
     /** When the subscription was cancelled */
-    cancellationDate?: string;   // exclusive
+    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 */
@@ -147,8 +145,7 @@ export interface UserPaidSubscription extends Subscription {
 }
 export namespace UserPaidSubscription {
     export function is(data: any): data is UserPaidSubscription {
-        return !!data
-            && data.hasOwnProperty('paymentReference');
+        return !!data && data.hasOwnProperty("paymentReference");
     }
 }
 
@@ -157,41 +154,44 @@ export interface AssignedTeamSubscription extends Subscription {
 }
 export namespace AssignedTeamSubscription {
     export function is(data: any): data is AssignedTeamSubscription {
-        return !!data
-            && data.hasOwnProperty('teamSubscriptionSlotId');
+        return !!data && data.hasOwnProperty("teamSubscriptionSlotId");
     }
 }
 
 export namespace Subscription {
-    export function create(newSubscription: Omit<Subscription, 'uid'>) {
+    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));
-    };
+        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 {
@@ -199,19 +199,19 @@ export namespace Subscription {
             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
+    startDate: string; // inclusive
+    endDate: string; // exclusive
 }
 
 export type MaybePeriod = Period | undefined;
 
-export type AccountEntryFixedPeriod = Omit<AccountEntry, 'uid'> & { expiryDate: string };
+export type AccountEntryFixedPeriod = Omit<AccountEntry, "uid"> & { expiryDate: string };
 export interface AccountStatement extends Period {
     userId: string;
     /**
@@ -223,9 +223,9 @@ export interface AccountStatement extends Period {
     /** Remaining valid hours (accumulated from credits) */
     remainingHours: RemainingHours;
 }
-export type RemainingHours = number | 'unlimited';
+export type RemainingHours = number | "unlimited";
 
 export interface CreditAlert {
-    userId: string,
-    remainingUsageHours: number
+    userId: string;
+    remainingUsageHours: number;
 }

package/src/admin-protocol.ts

@@ -5,9 +5,12 @@
  */
 
 import { User, Workspace, NamedWorkspaceFeatureFlag } from "./protocol";
+import { FindPrebuildsParams } from "./gitpod-service";
+import { Project, Team, PrebuildWithStatus, TeamMemberInfo, TeamMemberRole } 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>>;
@@ -17,11 +20,20 @@ export interface AdminServer {
     adminModifyRoleOrPermission(req: AdminModifyRoleOrPermissionRequest): Promise<User>;
     adminModifyPermanentWorkspaceFeatureFlag(req: AdminModifyPermanentWorkspaceFeatureFlagRequest): Promise<User>;
 
+    adminGetTeamMembers(teamId: string): Promise<TeamMemberInfo[]>;
+    adminGetTeams(req: AdminGetListRequest<Team>): Promise<AdminGetListResult<Team>>;
+    adminGetTeamById(id: string): Promise<Team | undefined>;
+    adminSetTeamMemberRole(teamId: string, userId: string, role: TeamMemberRole): Promise<void>;
+
     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>;
@@ -29,43 +41,48 @@ export interface AdminServer {
     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> {
-    offset: number
-    limit: number
-    orderBy: keyof T
-    orderDir: "asc" | "desc"
+    offset: number;
+    limit: number;
+    orderBy: keyof T;
+    orderDir: "asc" | "desc";
     searchTerm?: string;
 }
 
 export interface AdminGetListResult<T> {
-    total: number
-    rows: T[]
+    total: number;
+    rows: T[];
 }
 
 export interface AdminBlockUserRequest {
-    id: string
-    blocked: boolean
+    id: string;
+    blocked: boolean;
 }
 
 export interface AdminModifyRoleOrPermissionRequest {
     id: string;
     rpp: {
-        r: RoleOrPermission
-        add: boolean
-    }[]
+        r: RoleOrPermission;
+        add: boolean;
+    }[];
 }
 
 export interface AdminModifyPermanentWorkspaceFeatureFlagRequest {
     id: string;
     changes: {
-        featureFlag: NamedWorkspaceFeatureFlag
-        add: boolean
-    }[]
+        featureFlag: NamedWorkspaceFeatureFlag;
+        add: boolean;
+    }[];
 }
 
-export interface WorkspaceAndInstance extends Omit<Workspace, "id"|"creationTime">, Omit<WorkspaceInstance, "id"|"creationTime"> {
+export interface WorkspaceAndInstance
+    extends Omit<Workspace, "id" | "creationTime">,
+        Omit<WorkspaceInstance, "id" | "creationTime"> {
     workspaceId: string;
     workspaceCreationTime: string;
     instanceId: string;
@@ -78,7 +95,7 @@ export namespace WorkspaceAndInstance {
         return {
             id: wai.workspaceId,
             creationTime: wai.workspaceCreationTime,
-            ... wai
+            ...wai,
         };
     }
 
@@ -89,7 +106,7 @@ export namespace WorkspaceAndInstance {
         return {
             id: wai.instanceId,
             creationTime: wai.instanceCreationTime,
-            ... wai
+            ...wai,
         };
     }
 }
@@ -102,4 +119,4 @@ export type AdminGetWorkspacesQuery = {
     instanceId?: string;
     workspaceId?: string;
     ownerId?: string;
-};
+};

package/src/analytics.ts

@@ -4,49 +4,49 @@
  * 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 }
     | { 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 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">;
 export type RemotePageMessage = Omit<PageMessage, "timestamp" | "userId"> & {
-    anonymousId?: string | number;
+    includePII?: boolean;
 };
 
-export interface IAnalyticsWriter {
+export type RemoteIdentifyMessage = Omit<IdentifyMessage, "timestamp" | "userId">;
 
+export interface IAnalyticsWriter {
     identify(msg: IdentifyMessage): void;
 
     track(msg: TrackMessage): void;
 
     page(msg: PageMessage): void;
-
 }

package/src/auth.ts

@@ -11,14 +11,14 @@ export interface SelectAccountPayload {
         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 {

package/src/context-url.spec.ts

@@ -4,36 +4,64 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import * as chai from 'chai';
-import { suite, test } from 'mocha-typescript';
-import { ContextURL } from './context-url';
+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.parseToURL("passedin=test%20value/https://github.com/gitpod-io/gitpod-test-repo");
+        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.parseToURL("passedin=test%20value/github.com/gitpod-io/gitpod-test-repo");
+        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.parseToURL("prebuild/https://github.com/gitpod-io/gitpod-test-repo");
+        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.parseToURL("prebuild/github.com/gitpod-io/gitpod-test-repo");
+        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()
+module.exports = new ContextUrlTest();

package/src/context-url.ts

@@ -4,48 +4,106 @@
  * 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";
-
-  /**
-   * The field "contextUrl" might contain prefixes like:
-   *  - envvar1=value1/...
-   *  - prebuild/...
-   * This is the analogon to the (Prefix)ContextParser structure in "server".
-   */
-  export function parseToURL(contextUrl: string | undefined): URL | undefined {
-    if (contextUrl === undefined) {
-      return undefined;
+    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;
     }
 
-    const segments = contextUrl.split("/");
-    if (segments.length === 1) {
-      return new URL(segments[0]);  // this might be something, we just try
+    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;
     }
 
-    const segmentsToURL = (offset: number): URL => {
-      let rest = segments.slice(offset).join("/");
-      if (!rest.startsWith("http")) {
-        rest = 'https://' + rest;
-      }
-      return new URL(rest);
-    };
+    /**
+     * 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 firstSegment = segments[0];
-    if (firstSegment === PREBUILD_PREFIX ||
-        firstSegment === INCREMENTAL_PREBUILD_PREFIX ||
-        firstSegment === IMAGEBUILD_PREFIX) {
-      return segmentsToURL(1);
-    }
+        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;
+        };
 
-    // check for env vars
-    if (firstSegment.indexOf("=") !== -1) {
-      return segmentsToURL(1);
-    }
+        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);
+        }
 
-    return segmentsToURL(0);
-  }
-}
+        // check for env vars
+        if (firstSegment.indexOf("=") !== -1) {
+            return segmentsToURL(1);
+        }
+
+        return segmentsToURL(0);
+    }
+}