@vscode/test-web 0.0.57 → 0.0.59

package/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
+## 0.0.58
+ * new option `--commit` to specify the build of VS Code to use. By default the latest build is used.
+
 ## 0.0.37
  * new option `--testRunnerDataDir` to set the temporary folder for storing the VS Code builds used for running the tests
 
-
 ## 0.0.28
  * new option `--coi` to enable cross origin isolation.
 

package/README.md

@@ -80,6 +80,7 @@ CLI options:
 | --extensionDevelopmentPath | A path pointing to an extension under development to include. |
 | --extensionTestsPath | A path to a test module to run. |
 | --quality | `insiders` (default),  or `stable`. Ignored when sourcesPath is provided. |
+| --commit | commitHash The servion of the server to use. Defaults to latest build version of the given quality. Ignored when sourcesPath is provided. |
 | --sourcesPath | If set, runs the server from VS Code sources located at the given path. Make sure the sources and extensions are compiled (`yarn compile` and `yarn compile-web`). |
 | --headless | If set, hides the browser. Defaults to true when an extensionTestsPath is provided, otherwise false. |
 | --permission | Permission granted to the opened browser: e.g. `clipboard-read`, `clipboard-write`.  See [full list of options](https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions). Argument can be provided multiple times. |

package/fs-provider/dist/fsExtensionMain.js

@@ -35,14 +35,13 @@ function modifiedFileStat(stats, size) {
     return Promise.resolve({ type: stats.type, ctime: stats.ctime, mtime: Date.now(), size: size ?? stats.size });
 }
 class MemFileSystemProvider {
+    scheme;
+    root;
+    extensionUri;
     constructor(scheme, root, extensionUri) {
         this.scheme = scheme;
         this.root = root;
         this.extensionUri = extensionUri;
-        // --- manage file events
-        this._onDidChangeFile = new vscode_1.EventEmitter();
-        this.onDidChangeFile = this._onDidChangeFile.event;
-        this._bufferedChanges = [];
     }
     // --- manage file metadata
     async stat(resource) {
@@ -131,12 +130,14 @@ class MemFileSystemProvider {
         // Pattern is always blank: https://github.com/microsoft/vscode/issues/200892
         const glob = pattern ? new minimatch_1.Minimatch(pattern) : undefined;
         const result = [];
-        const dive = async (currentDirectory, pathSegments = []) => {
-            for (const [name, entry] of await currentDirectory.entries) {
+        const dive = async (folderUri) => {
+            const directory = await this._lookupAsDirectory(folderUri, false);
+            for (const [name, entry] of await directory.entries) {
+                /* support options.includes && options.excludes */
                 if (typeof options.maxResults !== 'undefined' && result.length >= options.maxResults) {
                     break;
                 }
-                const uri = vscode_1.Uri.joinPath(this.extensionUri, ...pathSegments, entry.name);
+                const uri = vscode_1.Uri.joinPath(folderUri, entry.name);
                 if (entry.type === vscode_1.FileType.File) {
                     const toMatch = uri.toString();
                     // Pattern is always blank: https://github.com/microsoft/vscode/issues/200892
@@ -145,11 +146,11 @@ class MemFileSystemProvider {
                     }
                 }
                 else if (entry.type === vscode_1.FileType.Directory) {
-                    await dive(entry, [...pathSegments, name]);
+                    await dive(uri);
                 }
             }
         };
-        await dive(this.root);
+        await dive(options.folder);
         return result;
     }
     async _lookup(uri, silent) {
@@ -204,6 +205,11 @@ class MemFileSystemProvider {
         const dirname = vscode_uri_1.Utils.dirname(uri);
         return this._lookupAsDirectory(dirname, false);
     }
+    // --- manage file events
+    _onDidChangeFile = new vscode_1.EventEmitter();
+    onDidChangeFile = this._onDidChangeFile.event;
+    _bufferedChanges = [];
+    _fireSoonHandle;
     watch(resource, opts) {
         // ignore, fires for all changes...
         return vscode_1.Disposable.from();
@@ -2615,11 +2621,16 @@ function activate(context) {
 }
 exports.activate = activate;
 class ServerBackedFile {
+    _serverRoot;
+    pathSegments;
+    name;
+    type = vscode_1.FileType.File;
+    _stats;
+    _content;
     constructor(_serverRoot, pathSegments, name) {
         this._serverRoot = _serverRoot;
         this.pathSegments = pathSegments;
         this.name = name;
-        this.type = vscode_1.FileType.File;
     }
     get stats() {
         if (this._stats === undefined) {
@@ -2641,11 +2652,16 @@ class ServerBackedFile {
     }
 }
 class ServerBackedDirectory {
+    _serverRoot;
+    pathSegments;
+    name;
+    type = vscode_1.FileType.Directory;
+    _stats;
+    _entries;
     constructor(_serverRoot, pathSegments, name) {
         this._serverRoot = _serverRoot;
         this.pathSegments = pathSegments;
         this.name = name;
-        this.type = vscode_1.FileType.Directory;
     }
     get stats() {
         if (this._stats === undefined) {

package/fs-provider/package-lock.json

@@ -936,14 +936,13 @@
 			"dev": true
 		},
 		"node_modules/micromatch": {
-			"version": "4.0.4",
-			"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
-			"integrity": "sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==",
+			"version": "4.0.8",
+			"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+			"integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
 			"dev": true,
-			"license": "MIT",
 			"dependencies": {
-				"braces": "^3.0.1",
-				"picomatch": "^2.2.3"
+				"braces": "^3.0.3",
+				"picomatch": "^2.3.1"
 			},
 			"engines": {
 				"node": ">=8.6"
@@ -1080,11 +1079,10 @@
 			"dev": true
 		},
 		"node_modules/picomatch": {
-			"version": "2.3.0",
-			"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.0.tgz",
-			"integrity": "sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw==",
+			"version": "2.3.1",
+			"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+			"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
 			"dev": true,
-			"license": "MIT",
 			"engines": {
 				"node": ">=8.6"
 			},

package/fs-provider/package.json

@@ -17,7 +17,8 @@
 		"onSearch:vscode-test-web"
 	],
 	"enabledApiProposals": [
-		"fileSearchProvider"
+		"fileSearchProvider",
+		"textSearchProvider"
 	],
 	"contributes": {
 		"resourceLabelFormatters": [

package/fs-provider/package.nls.json

@@ -0,0 +1,2 @@
+{
+}

package/out/browser/amd/main.js

@@ -0,0 +1,207 @@
+define("vscode-web-browser-main", ["require", "exports", "./workbench.api"], function (require, exports, workbench_api_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class WorkspaceProvider {
+        workspace;
+        payload;
+        static QUERY_PARAM_EMPTY_WINDOW = 'ew';
+        static QUERY_PARAM_FOLDER = 'folder';
+        static QUERY_PARAM_WORKSPACE = 'workspace';
+        static QUERY_PARAM_PAYLOAD = 'payload';
+        static create(config) {
+            let foundWorkspace = false;
+            let workspace;
+            let payload = Object.create(null);
+            const query = new URL(document.location.href).searchParams;
+            query.forEach((value, key) => {
+                switch (key) {
+                    case WorkspaceProvider.QUERY_PARAM_FOLDER:
+                        workspace = { folderUri: workbench_api_1.URI.parse(value) };
+                        foundWorkspace = true;
+                        break;
+                    case WorkspaceProvider.QUERY_PARAM_WORKSPACE:
+                        workspace = { workspaceUri: workbench_api_1.URI.parse(value) };
+                        foundWorkspace = true;
+                        break;
+                    case WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW:
+                        workspace = undefined;
+                        foundWorkspace = true;
+                        break;
+                    case WorkspaceProvider.QUERY_PARAM_PAYLOAD:
+                        try {
+                            payload = JSON.parse(value);
+                        }
+                        catch (error) {
+                            console.error(error);
+                        }
+                        break;
+                }
+            });
+            if (!foundWorkspace) {
+                if (config.folderUri) {
+                    workspace = { folderUri: workbench_api_1.URI.revive(config.folderUri) };
+                }
+                else if (config.workspaceUri) {
+                    workspace = { workspaceUri: workbench_api_1.URI.revive(config.workspaceUri) };
+                }
+            }
+            return new WorkspaceProvider(workspace, payload);
+        }
+        trusted = true;
+        constructor(workspace, payload) {
+            this.workspace = workspace;
+            this.payload = payload;
+        }
+        async open(workspace, options) {
+            if (options?.reuse && !options.payload && this.isSame(this.workspace, workspace)) {
+                return true;
+            }
+            const targetHref = this.createTargetUrl(workspace, options);
+            if (targetHref) {
+                if (options?.reuse) {
+                    window.location.href = targetHref;
+                    return true;
+                }
+                else {
+                    return !!window.open(targetHref);
+                }
+            }
+            return false;
+        }
+        createTargetUrl(workspace, options) {
+            let targetHref = undefined;
+            if (!workspace) {
+                targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW}=true`;
+            }
+            else if ('folderUri' in workspace) {
+                const queryParamFolder = encodeURIComponent(workspace.folderUri.toString(true));
+                targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_FOLDER}=${queryParamFolder}`;
+            }
+            else if ('workspaceUri' in workspace) {
+                const queryParamWorkspace = encodeURIComponent(workspace.workspaceUri.toString(true));
+                targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_WORKSPACE}=${queryParamWorkspace}`;
+            }
+            if (options?.payload) {
+                targetHref += `&${WorkspaceProvider.QUERY_PARAM_PAYLOAD}=${encodeURIComponent(JSON.stringify(options.payload))}`;
+            }
+            return targetHref;
+        }
+        isSame(workspaceA, workspaceB) {
+            if (!workspaceA || !workspaceB) {
+                return workspaceA === workspaceB;
+            }
+            if ('folderUri' in workspaceA && 'folderUri' in workspaceB) {
+                return this.isEqualURI(workspaceA.folderUri, workspaceB.folderUri);
+            }
+            if ('workspaceUri' in workspaceA && 'workspaceUri' in workspaceB) {
+                return this.isEqualURI(workspaceA.workspaceUri, workspaceB.workspaceUri);
+            }
+            return false;
+        }
+        isEqualURI(a, b) {
+            return a.scheme === b.scheme && a.authority === b.authority && a.path === b.path;
+        }
+    }
+    class LocalStorageURLCallbackProvider {
+        _callbackRoute;
+        static REQUEST_ID = 0;
+        static QUERY_KEYS = [
+            'scheme',
+            'authority',
+            'path',
+            'query',
+            'fragment'
+        ];
+        _onCallback = new workbench_api_1.Emitter();
+        onCallback = this._onCallback.event;
+        pendingCallbacks = new Set();
+        lastTimeChecked = Date.now();
+        checkCallbacksTimeout = undefined;
+        onDidChangeLocalStorageDisposable;
+        constructor(_callbackRoute) {
+            this._callbackRoute = _callbackRoute;
+        }
+        create(options = {}) {
+            const id = ++LocalStorageURLCallbackProvider.REQUEST_ID;
+            const queryParams = [`vscode-reqid=${id}`];
+            for (const key of LocalStorageURLCallbackProvider.QUERY_KEYS) {
+                const value = options[key];
+                if (value) {
+                    queryParams.push(`vscode-${key}=${encodeURIComponent(value)}`);
+                }
+            }
+            if (!(options.authority === 'vscode.github-authentication' && options.path === '/dummy')) {
+                const key = `vscode-web.url-callbacks[${id}]`;
+                localStorage.removeItem(key);
+                this.pendingCallbacks.add(id);
+                this.startListening();
+            }
+            return workbench_api_1.URI.parse(window.location.href).with({ path: this._callbackRoute, query: queryParams.join('&') });
+        }
+        startListening() {
+            if (this.onDidChangeLocalStorageDisposable) {
+                return;
+            }
+            const fn = () => this.onDidChangeLocalStorage();
+            window.addEventListener('storage', fn);
+            this.onDidChangeLocalStorageDisposable = { dispose: () => window.removeEventListener('storage', fn) };
+        }
+        stopListening() {
+            this.onDidChangeLocalStorageDisposable?.dispose();
+            this.onDidChangeLocalStorageDisposable = undefined;
+        }
+        async onDidChangeLocalStorage() {
+            const ellapsed = Date.now() - this.lastTimeChecked;
+            if (ellapsed > 1000) {
+                this.checkCallbacks();
+            }
+            else if (this.checkCallbacksTimeout === undefined) {
+                this.checkCallbacksTimeout = setTimeout(() => {
+                    this.checkCallbacksTimeout = undefined;
+                    this.checkCallbacks();
+                }, 1000 - ellapsed);
+            }
+        }
+        checkCallbacks() {
+            let pendingCallbacks;
+            for (const id of this.pendingCallbacks) {
+                const key = `vscode-web.url-callbacks[${id}]`;
+                const result = localStorage.getItem(key);
+                if (result !== null) {
+                    try {
+                        this._onCallback.fire(workbench_api_1.URI.revive(JSON.parse(result)));
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                    pendingCallbacks = pendingCallbacks ?? new Set(this.pendingCallbacks);
+                    pendingCallbacks.delete(id);
+                    localStorage.removeItem(key);
+                }
+            }
+            if (pendingCallbacks) {
+                this.pendingCallbacks = pendingCallbacks;
+                if (this.pendingCallbacks.size === 0) {
+                    this.stopListening();
+                }
+            }
+            this.lastTimeChecked = Date.now();
+        }
+        dispose() {
+            this._onCallback.dispose();
+        }
+    }
+    (function () {
+        const configElement = window.document.getElementById('vscode-workbench-web-configuration');
+        const configElementAttribute = configElement ? configElement.getAttribute('data-settings') : undefined;
+        if (!configElement || !configElementAttribute) {
+            throw new Error('Missing web configuration element');
+        }
+        const config = JSON.parse(configElementAttribute);
+        (0, workbench_api_1.create)(window.document.body, {
+            ...config,
+            workspaceProvider: WorkspaceProvider.create(config),
+            urlCallbackProvider: new LocalStorageURLCallbackProvider(config.callbackRoute)
+        });
+    })();
+});

package/out/browser/esm/main.js

@@ -0,0 +1,204 @@
+import { create, URI, Emitter } from './workbench.api';
+class WorkspaceProvider {
+    workspace;
+    payload;
+    static QUERY_PARAM_EMPTY_WINDOW = 'ew';
+    static QUERY_PARAM_FOLDER = 'folder';
+    static QUERY_PARAM_WORKSPACE = 'workspace';
+    static QUERY_PARAM_PAYLOAD = 'payload';
+    static create(config) {
+        let foundWorkspace = false;
+        let workspace;
+        let payload = Object.create(null);
+        const query = new URL(document.location.href).searchParams;
+        query.forEach((value, key) => {
+            switch (key) {
+                case WorkspaceProvider.QUERY_PARAM_FOLDER:
+                    workspace = { folderUri: URI.parse(value) };
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_WORKSPACE:
+                    workspace = { workspaceUri: URI.parse(value) };
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW:
+                    workspace = undefined;
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_PAYLOAD:
+                    try {
+                        payload = JSON.parse(value);
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                    break;
+            }
+        });
+        if (!foundWorkspace) {
+            if (config.folderUri) {
+                workspace = { folderUri: URI.revive(config.folderUri) };
+            }
+            else if (config.workspaceUri) {
+                workspace = { workspaceUri: URI.revive(config.workspaceUri) };
+            }
+        }
+        return new WorkspaceProvider(workspace, payload);
+    }
+    trusted = true;
+    constructor(workspace, payload) {
+        this.workspace = workspace;
+        this.payload = payload;
+    }
+    async open(workspace, options) {
+        if (options?.reuse && !options.payload && this.isSame(this.workspace, workspace)) {
+            return true;
+        }
+        const targetHref = this.createTargetUrl(workspace, options);
+        if (targetHref) {
+            if (options?.reuse) {
+                window.location.href = targetHref;
+                return true;
+            }
+            else {
+                return !!window.open(targetHref);
+            }
+        }
+        return false;
+    }
+    createTargetUrl(workspace, options) {
+        let targetHref = undefined;
+        if (!workspace) {
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW}=true`;
+        }
+        else if ('folderUri' in workspace) {
+            const queryParamFolder = encodeURIComponent(workspace.folderUri.toString(true));
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_FOLDER}=${queryParamFolder}`;
+        }
+        else if ('workspaceUri' in workspace) {
+            const queryParamWorkspace = encodeURIComponent(workspace.workspaceUri.toString(true));
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_WORKSPACE}=${queryParamWorkspace}`;
+        }
+        if (options?.payload) {
+            targetHref += `&${WorkspaceProvider.QUERY_PARAM_PAYLOAD}=${encodeURIComponent(JSON.stringify(options.payload))}`;
+        }
+        return targetHref;
+    }
+    isSame(workspaceA, workspaceB) {
+        if (!workspaceA || !workspaceB) {
+            return workspaceA === workspaceB;
+        }
+        if ('folderUri' in workspaceA && 'folderUri' in workspaceB) {
+            return this.isEqualURI(workspaceA.folderUri, workspaceB.folderUri);
+        }
+        if ('workspaceUri' in workspaceA && 'workspaceUri' in workspaceB) {
+            return this.isEqualURI(workspaceA.workspaceUri, workspaceB.workspaceUri);
+        }
+        return false;
+    }
+    isEqualURI(a, b) {
+        return a.scheme === b.scheme && a.authority === b.authority && a.path === b.path;
+    }
+}
+class LocalStorageURLCallbackProvider {
+    _callbackRoute;
+    static REQUEST_ID = 0;
+    static QUERY_KEYS = [
+        'scheme',
+        'authority',
+        'path',
+        'query',
+        'fragment'
+    ];
+    _onCallback = new Emitter();
+    onCallback = this._onCallback.event;
+    pendingCallbacks = new Set();
+    lastTimeChecked = Date.now();
+    checkCallbacksTimeout = undefined;
+    onDidChangeLocalStorageDisposable;
+    constructor(_callbackRoute) {
+        this._callbackRoute = _callbackRoute;
+    }
+    create(options = {}) {
+        const id = ++LocalStorageURLCallbackProvider.REQUEST_ID;
+        const queryParams = [`vscode-reqid=${id}`];
+        for (const key of LocalStorageURLCallbackProvider.QUERY_KEYS) {
+            const value = options[key];
+            if (value) {
+                queryParams.push(`vscode-${key}=${encodeURIComponent(value)}`);
+            }
+        }
+        if (!(options.authority === 'vscode.github-authentication' && options.path === '/dummy')) {
+            const key = `vscode-web.url-callbacks[${id}]`;
+            localStorage.removeItem(key);
+            this.pendingCallbacks.add(id);
+            this.startListening();
+        }
+        return URI.parse(window.location.href).with({ path: this._callbackRoute, query: queryParams.join('&') });
+    }
+    startListening() {
+        if (this.onDidChangeLocalStorageDisposable) {
+            return;
+        }
+        const fn = () => this.onDidChangeLocalStorage();
+        window.addEventListener('storage', fn);
+        this.onDidChangeLocalStorageDisposable = { dispose: () => window.removeEventListener('storage', fn) };
+    }
+    stopListening() {
+        this.onDidChangeLocalStorageDisposable?.dispose();
+        this.onDidChangeLocalStorageDisposable = undefined;
+    }
+    async onDidChangeLocalStorage() {
+        const ellapsed = Date.now() - this.lastTimeChecked;
+        if (ellapsed > 1000) {
+            this.checkCallbacks();
+        }
+        else if (this.checkCallbacksTimeout === undefined) {
+            this.checkCallbacksTimeout = setTimeout(() => {
+                this.checkCallbacksTimeout = undefined;
+                this.checkCallbacks();
+            }, 1000 - ellapsed);
+        }
+    }
+    checkCallbacks() {
+        let pendingCallbacks;
+        for (const id of this.pendingCallbacks) {
+            const key = `vscode-web.url-callbacks[${id}]`;
+            const result = localStorage.getItem(key);
+            if (result !== null) {
+                try {
+                    this._onCallback.fire(URI.revive(JSON.parse(result)));
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                pendingCallbacks = pendingCallbacks ?? new Set(this.pendingCallbacks);
+                pendingCallbacks.delete(id);
+                localStorage.removeItem(key);
+            }
+        }
+        if (pendingCallbacks) {
+            this.pendingCallbacks = pendingCallbacks;
+            if (this.pendingCallbacks.size === 0) {
+                this.stopListening();
+            }
+        }
+        this.lastTimeChecked = Date.now();
+    }
+    dispose() {
+        this._onCallback.dispose();
+    }
+}
+(function () {
+    const configElement = window.document.getElementById('vscode-workbench-web-configuration');
+    const configElementAttribute = configElement ? configElement.getAttribute('data-settings') : undefined;
+    if (!configElement || !configElementAttribute) {
+        throw new Error('Missing web configuration element');
+    }
+    const config = JSON.parse(configElementAttribute);
+    create(window.document.body, {
+        ...config,
+        workspaceProvider: WorkspaceProvider.create(config),
+        urlCallbackProvider: new LocalStorageURLCallbackProvider(config.callbackRoute)
+    });
+})();

package/out/server/download.js

@@ -4,11 +4,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDownloadURL = getDownloadURL;
 exports.downloadAndUnzipVSCode = downloadAndUnzipVSCode;
 exports.fetch = fetch;
 exports.fetchJSON = fetchJSON;
 exports.directoryExists = directoryExists;
 exports.fileExists = fileExists;
+exports.readFileInRepo = readFileInRepo;
 const fs_1 = require("fs");
 const path = require("path");
 const https = require("https");
@@ -16,9 +18,23 @@ const http = require("http");
 const https_proxy_agent_1 = require("https-proxy-agent");
 const http_proxy_agent_1 = require("http-proxy-agent");
 const url_1 = require("url");
-async function getLatestVersion(quality) {
-    const update = await fetchJSON(`https://update.code.visualstudio.com/api/update/web-standalone/${quality}/latest`);
-    return update;
+async function getLatestBuild(quality) {
+    return await fetchJSON(`https://update.code.visualstudio.com/api/update/web-standalone/${quality}/latest`);
+}
+async function getDownloadURL(quality, commit) {
+    return new Promise((resolve, reject) => {
+        const url = `https://update.code.visualstudio.com/commit:${commit}/web-standalone/${quality}`;
+        const httpLibrary = url.startsWith('https') ? https : http;
+        httpLibrary.get(url, { method: 'HEAD', ...getAgent(url) }, res => {
+            console.log(res.statusCode, res.headers.location);
+            if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) && res.headers.location) {
+                resolve(res.headers.location);
+            }
+            else {
+                resolve(undefined);
+            }
+        });
+    });
 }
 const reset = '\x1b[G\x1b[0K';
 async function downloadAndUntar(downloadUrl, destination, message) {
@@ -58,27 +74,38 @@ async function downloadAndUntar(downloadUrl, destination, message) {
         });
     });
 }
-async function downloadAndUnzipVSCode(quality, vscodeTestDir) {
-    const info = await getLatestVersion(quality);
-    const folderName = `vscode-web-${quality}-${info.version}`;
+async function downloadAndUnzipVSCode(vscodeTestDir, quality, commit) {
+    let downloadURL;
+    if (!commit) {
+        const info = await getLatestBuild(quality);
+        commit = info.version;
+        downloadURL = info.url;
+    }
+    const folderName = `vscode-web-${quality}-${commit}`;
     const downloadedPath = path.resolve(vscodeTestDir, folderName);
     if ((0, fs_1.existsSync)(downloadedPath) && (0, fs_1.existsSync)(path.join(downloadedPath, 'version'))) {
-        return { type: 'static', location: downloadedPath, quality, version: info.version };
+        return { type: 'static', location: downloadedPath, quality, version: commit };
+    }
+    if (!downloadURL) {
+        downloadURL = await getDownloadURL(quality, commit);
+        if (!downloadURL) {
+            throw Error(`Failed to find a download for ${quality} and ${commit}`);
+        }
     }
     if ((0, fs_1.existsSync)(vscodeTestDir)) {
-        await fs_1.promises.rmdir(vscodeTestDir, { recursive: true, maxRetries: 5 });
+        await fs_1.promises.rm(vscodeTestDir, { recursive: true, maxRetries: 5 });
     }
     await fs_1.promises.mkdir(vscodeTestDir, { recursive: true });
     const productName = `VS Code ${quality === 'stable' ? 'Stable' : 'Insiders'}`;
     try {
-        await downloadAndUntar(info.url, downloadedPath, `Downloading ${productName}`);
+        await downloadAndUntar(downloadURL, downloadedPath, `Downloading ${productName}`);
         await fs_1.promises.writeFile(path.join(downloadedPath, 'version'), folderName);
     }
     catch (err) {
         console.error(err);
-        throw Error(`Failed to download and unpack ${productName}`);
+        throw Error(`Failed to download and unpack ${productName}.${commit ? ' Did you specify a valid commit?' : ''}`);
     }
-    return { type: 'static', location: downloadedPath, quality, version: info.version };
+    return { type: 'static', location: downloadedPath, quality, version: commit };
 }
 async function fetch(api) {
     return new Promise((resolve, reject) => {
@@ -147,3 +174,6 @@ async function fileExists(path) {
         return false;
     }
 }
+async function readFileInRepo(pathInRepo) {
+    return (await fs_1.promises.readFile(path.resolve(__dirname, '../..', pathInRepo))).toString();
+}