The Web Portal uses a number of JavaScript files that are embedded into it. The one listed here in full, WebRest.js, is used by a number of the API calls. Look for strings of the form /api/XXX/YYYY. You can test these api strings in the SysInfo app using the api button. You can even experiment with parameters! Note that strings with /b/ in them don’t work as I think they are after something binary or use web sockets?? Any info on this is most welcome.

 // JavaScript source code
///<reference path="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.2-vsdoc.js" />

function WebbRest() {

    function getRegisteredEtwProviders() {
        var deferred = $.Deferred();
        httpGetExpect200("/api/etw/providers")
            .done(function (registeredProviders) {
                httpGetExpect200("/api/b/os/etw/customproviders")
                    .done(function(customProviders) {
                        if (registeredProviders.Providers && customProviders.Providers) {
                            registeredProviders.Providers = registeredProviders.Providers.concat(customProviders.Providers);
                        }
                        deferred.resolve(registeredProviders);
                    })
                    .fail(function (data, textStatus, error) {
                        deferred.resolve(registeredProviders);
                    })
            })
            .fail(function (data, textStatus, error) {
                deferred.reject(error);
            });

        return deferred;
    }

    function getRealtimeSessionStatus() {
        return httpGetExpect200("/api/etw/realtime/status");
    }

    function httpGetExpect200(uri) {
        var defered = $.Deferred();
        $.get(uri)
            .done(function (data, textStatus, error) {
                if (error.status == 200) {
                    defered.resolve(data);
                } else {
                    defered.reject(error);
                }
            })
            .fail(function (data, textStatus, error) {
                defered.reject(error);
            });

        return defered;
    }

    function httpPostExpect200(uri) {
        var defered = $.Deferred();
        $.post(uri)
            .done(function (data) {
                defered.resolve(data);
            })
            .fail(function (data, textStatus, error) {
                defered.reject(data, error);
            });

        return defered;
    }

    function changeProviderState(providerGuid, enabled, keywords, level) {
        var params = {
            op: (enabled ? 'enable' : 'disable'),
            provider: providerGuid
        };

        if (keywords && enabled) {
            params.keywords = keywords;
        }

        if (level && enabled) {
            params.level = level;
        }

        return httpGetExpect200("/api/etw/provider?" + $.param(params));
    }

    function providerCaptureState(providerGuid) {
        var params = {
            provider: providerGuid
        };

        return httpGetExpect200("/api/etw/capturestate?" + $.param(params));
    }

    // Only eventIDs that are enabled will be returned; if none are enabled,
    // all events are returned.
    function filterProviderByEventID(providerGuid, eventIDFilter, enableEvent) {
        var params = {
            op: (enableEvent ? 'enable' : 'disable'),
            eventid: eventIDFilter,
            provider: providerGuid
        };

        return httpPostExpect200("/api/etw/realtime/filter?" + $.param(params));
    }

    function clearProviderFilters(providerGuid) {
        return httpPostExpect200("/api/etw/realtime/filters/clear");
    }

    function getRealtimeEvents() {
        var deferred = $.Deferred();
        $.getJSON("/api/etw/realtime/events")
            .done(function (data, textStatus, error) {
                if (error.status == 200) {
                    data.RealtimeSessionRunning = true;
                    deferred.resolve(data);
                } else if (error.status == 204) {
                    deferred.resolve({ RealtimeSessionRunning: false });
                } else {
                    deferred.reject(error);
                }
            })
            .error(function (data, textStatus, error) {
                deferred.reject(error);
            });

        return deferred;
    }

    function getAppXDeploymentStatus() {
        return httpGetExpect200("/api/appx/deployment/status");
    }

    function getInstalledAppXPackages() {
        return httpGetExpect200("/api/appx/installed");
    }

    function uploadAppXPackageForCurrentDeployment(fileToUpload, progress) {
        return postFileWithProgress('/api/appx/deployment/package', fileToUpload, progress);
    }

    function uploadCertificateForCurrentDeployment(fileToUpload, progress) {
        return postFileWithProgress('/api/appx/deployment/certificate', fileToUpload, progress);
    }

    function uploadDependencyForCurrentDeployment(fileToUpload, progress) {
        return postFileWithProgress('/api/appx/deployment/dependency', fileToUpload, progress);
    }

    function commitAppXDeployment() {
        var deferred = $.Deferred();
        httpPostExpect200('/api/appx/deployment/commit')
            .done(function(){
                deferred.resolve();
            })
            .fail(function(data){
                var statusJSON = eval('(' + data.responseText + ')');
                deferred.reject(statusJSON);
            });

        return deferred.promise();
    }

    function startAppx(packageName) {
        var params = {appid : window.btoa(packageName)};
        return httpPostExpect200("/api/taskmanager/start?" + $.param(params));
    }

    function stopAppx(packageName, forceStop) {
        var params = {package : window.btoa(packageName)};
        if (forceStop) {
            params.forcestop = (forceStop === true ? true : false);
        }
        return httpPostExpect200("/api/taskmanager/stop?" + $.param(params));
    }

    function stopProcess(pid) {
        var params = {pid : pid};
        return httpPostExpect200("/api/taskmanager/stop?" + $.param(params));
    }

    function resetAppXDeployment() {
        return httpPostExpect200('/api/appx/deployment/reset');
    }

    function uninstallAppXPackage(packageName) {
        var params = {package: packageName};
        return httpPostExpect200('/api/appx/uninstall?' + $.param(params));
    }

    function postFileWithProgress(uri, file, progress) {

        var deferred = $.Deferred();

        var xhr = new XMLHttpRequest();

        if ( xhr.upload && progress) {
            xhr.upload.onprogress = function(e) {
                var done = e.position || e.loaded, total = e.totalSize || e.total;
                progress(done, total, Math.floor(done/total*1000)/10);
            };
        }
        xhr.onreadystatechange = function() {
            if (this.readyState == 4) {
                if (this.status == 200) {
                    deferred.resolve();
                } else {
                    deferred.reject();
                }
            }
        };

        var form_data = new FormData();
        form_data.append(file.name, file);

        xhr.open('post', uri, true);
        xhr.send(form_data);

        return deferred;
    }

    function getProcessList() {
        return httpGetExpect200("/api/resourcemanager/processes");
    }

    function getBugcheckDumpsList() {
        return httpGetExpect200("/api/debug/dump/kernel/dumplist");
    }

    this.CrashControlSettings = {
        DumpType : "dumptype",
        AutoReboot : "autoreboot",
        MaxDumpCount : "maxdumpcount",
        Overwrite : "overwrite"
    };
    this.CrashControlDumpTypes = {
        "Disabled" : {value : 0, Description: "Disabled"},
        "MemoryDump" : {value : 1, Description: "Complete memory dump (in use memory)"},
        "KernelDump" : {value : 2, Description: "Kernel memory dump (no user mode memory)"},
        "Minidump" : {value : 3, Description: "Limited kernel minidump"}
    };

    function getCrashControlSettings() {
        return httpGetExpect200("/api/debug/dump/kernel/crashcontrol");
    }

    function setCrashControlSettings(settings) {
        return httpPostExpect200('/api/debug/dump/kernel/crashcontrol?' + $.param(settings));
    }

    function reboot() {
        return httpPostExpect200('api/control/reboot');
    }

    function shutdown() {
        return httpPostExpect200('api/control/shutdown');
    }

    function getDeviceList() {
        return httpGetExpect200("/api/devicemanager/devices");
    }

    function getWirelessInterfaces() {
        return httpGetExpect200("/api/wifi/interfaces");
    }

    function getAvailableWirelessNetworks(interfaceGuid) {
        return httpGetExpect200("/api/wifi/networks?" + $.param({interface : interfaceGuid}));
    }

    function deleteWifiProfile(profileName) {
        var params = {profilename : window.btoa(profileName), op : "delete"};
        return httpPostExpect200("/api/wifi/profile?");
    }

    function connectToNetwork(interfaceGuid, ssid, key, createProfile) {
        var params = {interface : interfaceGuid, ssid : ssid, op : "connect"};
        params.createprofile = (createProfile === true ? "yes" : "no");
        if (key) {
            params.key = window.btoa(key);
        }
        return httpPostExpect200("/api/wifi/network?" + $.param(params));
    }

    function connectToNetworkUsingProfile(interfaceGuid, profileName) {
        var params = {interface : interfaceGuid, profile : window.btoa(profileName), op : "connect"};
        return httpPostExpect200("/api/wifi/network?" + $.param(params));
    }

    function disconnectFromNetwork(interfaceGuid) {
        return httpPostExpect200("/api/wifi/network?" + $.param({interface : interfaceGuid, op : "disconnect"}));
    }

    function deleteWifiProfile(interfaceGuid, profileName) {
        return httpPostExpect200("/api/wifi/profile?" + $.param({interface : interfaceGuid, op : "delete", profile :  window.btoa(profileName)}));
    }

    function getIpConfig(interfaceGuid) {
        return httpGetExpect200("/api/networking/ipconfig");
    }

    function setComputerName(name) {
        return httpPostExpect200("/api/swinfo/machinename?" + $.param({name : window.btoa(name)}));
    }

    function getComputerName() {
        return httpGetExpect200("/api/swinfo/machinename");
    }

    function getWerReports() {
        return httpGetExpect200("/api/wer/reports");
    }

    function getWerReportFiles(user, type, name) {
        var params = {user : user, type : type};
        params.name = window.btoa(name);
        return httpGetExpect200("/api/wer/report/files?" + $.param(params));
    }

    function getWerReportFileDownloadLink(user, type, name, fileName) {
        var params = {user : user, type : type};
        params.name = window.btoa(name);
        params.file = window.btoa(fileName);
        return "/api/wer/report/file?" + $.param(params);
    }

    function downloadWerReportFile(user, type, name, fileName) {
        var params = {user : user, type : type};
        params.name = window.btoa(name);
        params.file = window.btoa(fileName);
        return httpGetExpect200("/api/wer/report/file?" + $.param(params));
    }

    function setComputerName(name) {
        return this.httpPostExpect200("/api/b/os/machinename?" + $.param({name : window.btoa(name)}));
    }

    function getComputerName() {
        return this.httpGetExpect200("/api/b/os/machinename");
    }
    
	function getSoftwareInfo() {
        return this.httpGetExpect200("api/os/info");
    }

    $.extend(this, {
        // methods
        "getRegisteredEtwProviders": getRegisteredEtwProviders,
        "getRealtimeEvents": getRealtimeEvents,
        "getRealtimeSessionStatus": getRealtimeSessionStatus,
        "changeProviderState": changeProviderState,
        "providerCaptureState": providerCaptureState,
        "filterProviderByEventID": filterProviderByEventID,

        "reboot": reboot,
        "shutdown": shutdown,

        "getDeviceList" : getDeviceList,

        "getInstalledAppXPackages": getInstalledAppXPackages,
        "getAppXDeploymentStatus": getAppXDeploymentStatus,
        "commitAppXDeployment": commitAppXDeployment,
        "resetAppXDeployment": resetAppXDeployment,
        "uploadAppXPackageForCurrentDeployment": uploadAppXPackageForCurrentDeployment,
        "uploadCertificateForCurrentDeployment": uploadCertificateForCurrentDeployment,
        "uploadDependencyForCurrentDeployment": uploadDependencyForCurrentDeployment,
        "uninstallAppXPackage" : uninstallAppXPackage,
        "startAppx" : startAppx,
        "stopAppx" : stopAppx,

        "stopProcess" : stopProcess,

        "getProcessList" : getProcessList,

        "getBugcheckDumpsList" : getBugcheckDumpsList,
        "getCrashControlSettings" : getCrashControlSettings,
        "setCrashControlSettings" : setCrashControlSettings,

        "getWirelessInterfaces" : getWirelessInterfaces,
        "getAvailableWirelessNetworks" : getAvailableWirelessNetworks,
        "connectToNetwork" : connectToNetwork,
        "connectToNetworkUsingProfile" : connectToNetworkUsingProfile,
        "disconnectFromNetwork" : disconnectFromNetwork,
        "deleteWifiProfile" : deleteWifiProfile,

        "getIpConfig" : getIpConfig,

        "getWerReports" : getWerReports,
        "getWerReportFiles" : getWerReportFiles,
        "getWerReportFileDownloadLink" : getWerReportFileDownloadLink,
        "downloadWerReportFile" : downloadWerReportFile,

        "setComputerName" : setComputerName,
        "getComputerName" : getComputerName,
		"getSoftwareInfo" : getSoftwareInfo,

        "httpGetExpect200" : httpGetExpect200,
        "httpPostExpect200" : httpPostExpect200
    });
}

function ProcessDataUpdater() {
    var self = this;
    self.dataAvailable = $.Callbacks();
    self.errorGettingData = $.Callbacks();
    self.connectionClosed = $.Callbacks();

        
    this.start = function() {
        var websocketProtocol = (document.location.protocol === 'https:' ? 'wss://' : 'ws://');
        var host = websocketProtocol + window.location.host + '/api/resourcemanager/processes';
        this.socket = new WebSocket(host);

        this.socket.onmessage = function (messageEvent) {
            var processData = JSON.parse(messageEvent.data);
            self.dataAvailable.fire(processData.Processes);
        }

        this.socket.onerror = function (errorEvent) {
            self.errorGettingData.fire();
        };

        this.socket.onclose = function (closeEvent) {
            self.connectionClosed.fire();
        };
    };

    this.stop = function() {
        this.socket.close();
    };
}