querysub 0.234.0 → 0.236.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.234.0",
+  "version": "0.236.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -22,7 +22,7 @@
     "js-sha512": "^0.9.0",
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
-    "socket-function": "^0.132.0",
+    "socket-function": "^0.133.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.22.0",
     "yaml": "^2.5.0",

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -7,10 +7,13 @@ import { Querysub } from "../../4-querysub/QuerysubController";
 import { currentViewParam, selectedServiceIdParam, selectedMachineIdParam } from "../urlParams";
 import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { InputPicker } from "../../library-components/InputPicker";
-import { sort } from "socket-function/src/misc";
+import { nextId, sort } from "socket-function/src/misc";
 import { InputLabel } from "../../library-components/InputLabel";
 import { Button } from "../../library-components/Button";
 import { isDefined } from "../../misc";
+import { watchScreenOutput, stopWatchingScreenOutput } from "../machineController";
+import { getPathStr2 } from "../../path";
+import { ScrollOnMount } from "../../library-components/ScrollOnMount";
 
 // Type declarations for Monaco editor
 declare global {
@@ -25,12 +28,17 @@ declare global {
 
 export class ServiceDetailPage extends qreact.Component {
     state = t.state({
-        unsavedChanges: t.atomic<ServiceConfig | undefined>(undefined),
-        isSaving: t.atomic<boolean>(false),
+        unsavedChanges: t.type<ServiceConfig | undefined>(undefined),
+        isSaving: t.type(false),
         saveError: t.string,
         expandedErrors: t.lookup({
-            expanded: t.atomic<boolean>(false)
-        })
+            expanded: t.type(false)
+        }),
+        watchingOutputs: t.lookup({
+            isWatching: t.type(false),
+            data: t.type(""),
+            callbackId: t.type(""),
+        }),
     });
 
     private async ensureMonacoLoaded(): Promise<void> {
@@ -95,6 +103,54 @@ type ServiceConfig = ${serviceConfigType}
             void this.updateConfig(updatedConfig);
         });
     }
+
+    private async startWatchingOutput(config: {
+        nodeId: string;
+        key: string;
+        index: number;
+    }) {
+        const { nodeId, key, index } = config;
+        const outputKey = getPathStr2(key, index + "");
+        let callbackId = nextId();
+
+        Querysub.commit(() => {
+            this.state.watchingOutputs[outputKey] = { isWatching: true, data: "", callbackId };
+        });
+
+        try {
+            await watchScreenOutput({
+                nodeId,
+                key,
+                index,
+                callbackId,
+                onData: async (data: string) => {
+                    Querysub.localCommit(() => {
+                        let fullData = this.state.watchingOutputs[outputKey].data + data;
+                        fullData = fullData.slice(-10000);
+                        this.state.watchingOutputs[outputKey].data = fullData;
+                    });
+                }
+            });
+        } catch (error: any) {
+            Querysub.localCommit(() => {
+                this.state.watchingOutputs[outputKey].data = `Error watching output: ${error.stack || String(error)}`;
+            });
+        }
+    }
+
+    private async stopWatchingOutput(key: string, index: number) {
+        const outputKey = getPathStr2(key, index + "");
+
+        let callbackId = Querysub.localRead(() => {
+            const watchingState = this.state.watchingOutputs[outputKey];
+            watchingState.isWatching = false;
+            return watchingState.callbackId;
+        });
+
+        Querysub.onCommitFinished(async () => {
+            await stopWatchingScreenOutput({ callbackId });
+        });
+    }
     private async updateConfig(updatedConfig: ServiceConfig): Promise<void> {
         const selectedServiceId = selectedServiceIdParam.value;
         if (!selectedServiceId) return;
@@ -150,7 +206,10 @@ type ServiceConfig = ${serviceConfigType}
         const hasUnsavedChanges = !!this.state.unsavedChanges;
 
         // Sort machines by status and heartbeat
+        let nextIndexes = new Map<string, number>();
         let machineStatuses = config.machineIds.map(machineId => {
+            let index = nextIndexes.get(machineId) || 0;
+            nextIndexes.set(machineId, index + 1);
             let machineInfo = controller.getMachineInfo(machineId);
             const serviceInfo = machineInfo?.services[selectedServiceId || ""];
             const isMachineDead = machineInfo ? Date.now() - machineInfo.heartbeat > (MACHINE_RESYNC_INTERVAL * 4) : true;
@@ -162,7 +221,8 @@ type ServiceConfig = ${serviceConfigType}
                 serviceInfo,
                 isMachineDead,
                 hasError,
-                heartbeat: machineInfo?.heartbeat || 0
+                heartbeat: machineInfo?.heartbeat || 0,
+                index
             };
         });
         sort(machineStatuses, x => (x.hasError ? 0 : x.isMachineDead ? 1 : 2) * 1000000 + x.heartbeat);
@@ -247,7 +307,7 @@ type ServiceConfig = ${serviceConfigType}
             {configT.parameters.deploy && <div className={css.vbox(8)}>
                 <h3>Deployed Machines ({config.machineIds.length})</h3>
                 <div className={css.vbox(4)}>
-                    {machineStatuses.map(({ machineId, machineInfo, serviceInfo, isMachineDead, hasError }) => {
+                    {machineStatuses.map(({ machineId, machineInfo, serviceInfo, isMachineDead, hasError, index }) => {
                         if (!machineInfo) return <div key={machineId}>Loading {machineId}...</div>;
 
                         let backgroundColor = css.hsl(0, 0, 100); // Default: white
@@ -259,6 +319,11 @@ type ServiceConfig = ${serviceConfigType}
                             backgroundColor = css.hsl(30, 70, 90); // Orange for not deployed
                         }
 
+                        let key = config.parameters.key;
+                        const outputKey = getPathStr2(key, index + "");
+                        const isWatching = this.state.watchingOutputs[outputKey].isWatching;
+                        const outputData = this.state.watchingOutputs[outputKey].data;
+
                         return <div key={machineId}
                             className={css.pad2(12).button.bord2(0, 0, 20) + backgroundColor}
                             onClick={() => {
@@ -297,6 +362,25 @@ type ServiceConfig = ${serviceConfigType}
                                         Not Running
                                     </div>
                                 )}
+
+                                <div
+                                    className={css.pad2(8, 4).button}
+                                    onClick={(e) => {
+                                        e.stopPropagation();
+                                        let applyNodeId = machineInfo.applyNodeId;
+                                        Querysub.onCommitFinished(() => {
+                                            if (isWatching) {
+                                                void this.stopWatchingOutput(key, index);
+                                            } else {
+                                                void this.startWatchingOutput({ nodeId: applyNodeId, key, index });
+                                            }
+                                        });
+                                    }}
+                                >
+                                    <div className={css.pad2(4, 8).bord2(0, 0, 10) + (isWatching ? css.hsl(0, 70, 90) : css.hsl(120, 70, 90))}>
+                                        {isWatching ? "Stop Watching Output" : "Watch Screen Output"}
+                                    </div>
+                                </div>
                             </div>
                             {hasError && (
                                 <div
@@ -324,6 +408,20 @@ type ServiceConfig = ${serviceConfigType}
                                     )}
                                 </div>
                             )}
+
+                            {isWatching && (
+                                <div
+                                    className={
+                                        css.pad2(8).bord2(0, 0, 10).hsl(0, 0, 10).colorhsl(0, 0, 100)
+                                            .whiteSpace("pre-wrap").fontFamily("monospace")
+                                            .overflowAuto
+                                            .maxHeight("60vh")
+                                    }
+                                >
+                                    {outputData && outputData || "Waiting for output..."}
+                                    <ScrollOnMount debugText={`Screen ${outputKey}`} />
+                                </div>
+                            )}
                         </div>;
                     })}
                 </div>

package/src/deployManager/machineApplyMainCode.ts

@@ -4,7 +4,7 @@ import { measureWrap } from "socket-function/src/profiling/measure";
 import { getOwnMachineId } from "../-a-auth/certs";
 import { getOurNodeId, getOurNodeIdAssert } from "../-f-node-discovery/NodeDiscovery";
 import { Querysub } from "../4-querysub/QuerysubController";
-import { MACHINE_RESYNC_INTERVAL, DeployControllerBase, MachineInfo, ServiceConfig, onServiceConfigChange, serviceConfigs, SERVICE_FOLDER, machineInfos } from "./machineSchema";
+import { MACHINE_RESYNC_INTERVAL, DeployControllerBase, MachineInfo, ServiceConfig, serviceConfigs, SERVICE_FOLDER, machineInfos } from "./machineSchema";
 import { runPromise } from "../functional/runCommand";
 import { getExternalIP } from "socket-function/src/networking";
 import { errorToUndefined, errorToUndefinedSilent } from "../errors";
@@ -16,10 +16,13 @@ import { logLoadTime } from "../logModuleLoadTimes";
 import { delay, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import os from "os";
 import fs from "fs";
+import { spawn, ChildProcess } from "child_process";
 import { lazy } from "socket-function/src/caching";
 import { getGitRefLive, setGitRef } from "../4-deploy/git";
-import { blue, green, magenta } from "socket-function/src/formatting/logColors";
+import { blue, green, magenta, red } from "socket-function/src/formatting/logColors";
 import { shutdown } from "../diagnostics/periodic";
+import { onServiceConfigChange } from "./machineController";
+import { PromiseObj } from "../promise";
 
 const getLiveMachineInfo = measureWrap(async function getLiveMachineInfo() {
     let machineInfo: MachineInfo = {
@@ -43,6 +46,91 @@ function getScreenName(config: { serviceKey: string; index: number }): string {
     return `${config.serviceKey}-${config.index}${SCREEN_SUFFIX}`.replace(/[^a-zA-Z0-9\-_]/g, "_");
 }
 
+export async function streamScreenOutput(config: {
+    key: string;
+    index: number;
+    onData: (data: string) => Promise<void>;
+}) {
+    let screenName = getScreenName({
+        serviceKey: config.key,
+        index: config.index,
+    });
+    let serialOnData = runInSerial(config.onData);
+    let stopped = false;
+    let childProcess: ChildProcess | undefined;
+    const prefix = getTmuxPrefix();
+
+    let pendingDataCalls = 0;
+    const MAX_PENDING_CALLS = 100;
+
+    const onDataWrapped = async (data: string) => {
+        pendingDataCalls++;
+        if (pendingDataCalls > MAX_PENDING_CALLS) {
+            console.error(`Too many queued onData calls for ${screenName}, stopping stream.`);
+            await stop();
+            return;
+        }
+        try {
+            await serialOnData(data);
+        } catch (e: any) {
+            console.log(`Callback for stream output ${screenName} failed. It probably just disconnected, almost certainly not an error: ${e.stack}`);
+            await stop();
+        } finally {
+            pendingDataCalls--;
+        }
+    };
+
+    async function stop() {
+        if (stopped) return;
+        stopped = true;
+
+        if (childProcess) {
+            childProcess.kill();
+        }
+    }
+
+    return (async () => {
+        try {
+            const captureCommand = `${prefix}tmux capture-pane -p -S -2000 -t ${screenName}`;
+            // Initial data
+            const initialContent = await runPromise(captureCommand, { quiet: true });
+            if (initialContent) {
+                await onDataWrapped(initialContent);
+            }
+
+            childProcess = spawn(`${prefix}tmux pipe-pane -t ${screenName}`, {
+                shell: true,
+                stdio: "pipe",
+            });
+
+            let started = new PromiseObj<void>();
+
+            childProcess.stdout?.on("data", (data) => {
+                if (stopped) return;
+                started.resolve();
+                void onDataWrapped(data.toString());
+            });
+            // Give it some time to error out, otherwise, just start
+            setTimeout(() => started.resolve(), 200);
+
+            childProcess.stderr?.on("data", (data) => {
+                if (stopped) return;
+                void onDataWrapped(red(data.toString()));
+            });
+
+            childProcess.on("error", async (err) => {
+                if (stopped) return;
+                started.reject(err);
+            });
+
+            await started.promise;
+        } catch (e) {
+            void stop();
+            throw e;
+        }
+    })();
+}
+
 
 const getTmuxPrefix = lazy(() => {
     if (os.platform() === "win32") {

package/src/deployManager/machineController.ts

@@ -0,0 +1,160 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { lazy } from "socket-function/src/caching";
+import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
+import { timeInMinute } from "socket-function/src/misc";
+import { assertIsManagementUser } from "../diagnostics/managementPages";
+import { isNode } from "typesafecss";
+import { streamScreenOutput } from "./machineApplyMainCode";
+import { Querysub } from "../4-querysub/QuerysubController";
+import { getPathStr2 } from "../path";
+
+const POLL_INTERVAL = timeInMinute * 15;
+
+// Only works if our self id has been registered as applyNodeId (with setMachineInfo).
+let serviceConfigChangeWatchers = new Set<() => Promise<void>>();
+
+let triggerServiceConfigChangeCallbacks = runInSerial(async () => {
+    for (let callback of serviceConfigChangeWatchers) {
+        await callback();
+    }
+});
+let setupPoll = lazy(() => {
+    void runInfinitePollCallAtStart(POLL_INTERVAL, triggerServiceConfigChangeCallbacks);
+});
+
+// NOTE: The callback should block until the changes are applied (possibly throwing). This way the change results can be deployed and when the changer function finishes it will automatically reload them.
+export function onServiceConfigChange(callback: () => Promise<void>): () => void {
+    serviceConfigChangeWatchers.add(callback);
+    setupPoll();
+    return () => {
+        serviceConfigChangeWatchers.delete(callback);
+    };
+}
+class OnServiceChangeBase {
+    public async onServiceConfigChange() {
+        await triggerServiceConfigChangeCallbacks();
+    }
+}
+export const OnServiceChange = SocketFunction.register(
+    "on-service-change-aa6b4aaa-c325-4112-b2a8-f81c180016a0",
+    () => new OnServiceChangeBase(),
+    () => ({
+        onServiceConfigChange: {},
+    }),
+    () => ({
+        hooks: [requiresNetworkTrustHook],
+    }),
+);
+
+
+class MachineControllerBase {
+    // NOTE: We don't need to worry about escaping commands here. YES, the user CAN inject code into the key. But this system is literally for running arbitrary commands, so they could just write a serviceConfig and run anything they want, on all the machines...
+    public async streamScreenOutput(config: {
+        key: string;
+        index: number;
+        callbackId: string;
+    }): Promise<void> {
+        let caller = SocketFunction.getCaller();
+        await streamScreenOutput({
+            key: config.key,
+            index: config.index,
+            onData: async (data) => {
+                await MachineControllerClient.nodes[caller.nodeId].onScreenOutput({
+                    key: config.key,
+                    index: config.index,
+                    data,
+                    callbackId: config.callbackId,
+                });
+            },
+        });
+    }
+    // We need to forward it, as clients can't connect to servers directly (as they don't have real HTTP certificates).
+    public async watchOtherScreenOutput(config: {
+        nodeId: string;
+        key: string;
+        index: number;
+        callbackId: string;
+    }) {
+        let caller = SocketFunction.getCaller();
+        forwardedCallbacks.set(config.callbackId, caller.nodeId);
+        await MachineController.nodes[config.nodeId].streamScreenOutput({
+            key: config.key,
+            index: config.index,
+            callbackId: config.callbackId,
+        });
+    }
+}
+
+let forwardedCallbacks = new Map<string, string>();
+
+const MachineController = SocketFunction.register(
+    "machine-controller-c3157d4a-580c-4e76-9dc9-072dd92e70af",
+    () => new MachineControllerBase(),
+    () => ({
+        streamScreenOutput: {},
+        watchOtherScreenOutput: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+);
+
+let callbacks = new Map<string, (data: string) => Promise<void>>();
+export async function watchScreenOutput(config: {
+    nodeId: string;
+    key: string;
+    index: number;
+    callbackId: string;
+    onData: (data: string) => Promise<void>;
+}) {
+    let callbackId = config.callbackId;
+    callbacks.set(callbackId, config.onData);
+    await MachineController.nodes[SocketFunction.browserNodeId()].watchOtherScreenOutput({
+        nodeId: config.nodeId,
+        key: config.key,
+        index: config.index,
+        callbackId,
+    });
+}
+
+export async function stopWatchingScreenOutput(config: {
+    callbackId: string;
+}) {
+    let callbackId = config.callbackId;
+    callbacks.delete(callbackId);
+}
+class MachineControllerClientBase {
+    public async onScreenOutput(config: {
+        key: string;
+        index: number;
+        data: string;
+        callbackId: string;
+    }): Promise<void> {
+        let forwardToNodeId = forwardedCallbacks.get(config.callbackId);
+        if (forwardToNodeId) {
+            await MachineControllerClient.nodes[forwardToNodeId].onScreenOutput({
+                key: config.key,
+                index: config.index,
+                data: config.data,
+                callbackId: config.callbackId,
+            });
+            return;
+        }
+
+        let callback = callbacks.get(config.callbackId);
+        if (!callback) {
+            throw new Error(`Callback ${config.callbackId} not found (likely removed)`);
+        }
+        await callback(config.data);
+    }
+}
+// NOTE: THis is secure, because callbackId is random.
+const MachineControllerClient = SocketFunction.register(
+    "machine-controller-client-2bcc6c02-96e4-4521-bbb9-2776e7a14d08",
+    () => new MachineControllerClientBase(),
+    () => ({
+        onScreenOutput: {},
+    }),
+    () => ({}),
+);

package/src/deployManager/machineSchema.ts

@@ -14,10 +14,11 @@ import { runInSerial, runInfinitePollCallAtStart } from "socket-function/src/bat
 import { lazy } from "socket-function/src/caching";
 import { errorToUndefinedSilent } from "../errors";
 import { getGitRefLive, getGitURLLive } from "../4-deploy/git";
+import { OnServiceChange } from "./machineController";
 
 export const SERVICE_FOLDER = "machine-services/";
 export const MACHINE_RESYNC_INTERVAL = timeInMinute * 15;
-const POLL_INTERVAL = timeInMinute * 15;
+
 
 export type ServiceConfig = {
     /** Just a random id to manage the service */
@@ -80,43 +81,6 @@ export const serviceConfigs = archiveJSONT<ServiceConfig>(() => nestArchives("ma
 export const machineInfos = archiveJSONT<MachineInfo>(() => nestArchives("machines/machine-heartbeats/", getArchivesBackblaze(getDomain())));
 
 
-// Only works if our self id has been registered as applyNodeId (with setMachineInfo).
-let serviceConfigChangeWatchers = new Set<() => Promise<void>>();
-
-let triggerCallbacks = runInSerial(async () => {
-    for (let callback of serviceConfigChangeWatchers) {
-        await callback();
-    }
-});
-let setupPoll = lazy(() => {
-    void runInfinitePollCallAtStart(POLL_INTERVAL, triggerCallbacks);
-});
-
-// NOTE: The callback should block until the changes are applied (possibly throwing). This way the change results can be deployed and when the changer function finishes it will automatically reload them.
-export function onServiceConfigChange(callback: () => Promise<void>): () => void {
-    serviceConfigChangeWatchers.add(callback);
-    setupPoll();
-    return () => {
-        serviceConfigChangeWatchers.delete(callback);
-    };
-}
-class OnServiceChangeBase {
-    public async onServiceConfigChange() {
-        await triggerCallbacks();
-    }
-}
-const OnServiceChange = SocketFunction.register(
-    "on-service-change-aa6b4aaa-c325-4112-b2a8-f81c180016a0",
-    () => new OnServiceChangeBase(),
-    () => ({
-        onServiceConfigChange: {},
-    }),
-    () => ({
-        hooks: [requiresNetworkTrustHook],
-    }),
-);
-
-
 export class DeployControllerBase {
 
     public async getMachineList(): Promise<string[]> {

package/src/deployManager/spec.txt

@@ -1,31 +1,47 @@
-NOTE: Yarn 
+3) Hmm... being able to watch the output for a service would be useful, and... it should be... trivial to do?
+    - Buttons per key + index, which we can figure out clientside. Stream results under the button, and we can stream multiple at once?
+    - OH, just for superusers, so the browser can connect directly!
 
-7.1) Better infinite poll support in shutdown
-    - Stop all loops
-    - If any are running, wait (with timeout, same as with regular handlers), for them to finish
-
-4) Kill our testing server
+4) Destroy our testing digital ocean server
 
 5) Setup on our regular digital ocean server
     - Remove previous startup.sh, and crontab and kill existing tmux services
     - Setup all the services in the new UI
         - Copy from the previous startup.sh, running the same services
         - Changing the UI if anything is extremely annoying, but... I don't see how it would be...
+    tmux send-keys -t server1 "cd ~/cyoa && yarn server-public" Enter
+    tmux send-keys -t server2 "cd ~/cyoa && yarn server-public" Enter
+    tmux send-keys -t fnc "cd ~/cyoa && yarn function-public --verbosecalls" Enter
+    tmux send-keys -t http "cd ~/cyoa && yarn cyoa-public --verbosecalls" Enter
+    tmux send-keys -t watch "cd ~/cyoa && yarn gc-watch-public" Enter
+    tmux send-keys -t join "cd ~/cyoa && yarn join-public" Enter
 5) Verify the editor works
 
 6) Verify PathValueServer gracefully shutdowns, not losing any values (because it delays and flushes writes before shutting down, detecting the ctrl+c).
 
 
-7) Quick node removal on process crash or removal
-    Detect the nodeId of services (if they have one), and when the service dies, immediately remove "edgenodes/" file, and trigger an update of "edge-nodes-index.json"
-    - How? Damn it, I have no idea. Maybe... they can determine their screen from their pid and then write to their screen folder? That seems... the best way, even though it's extremely coupling.
+7) Quick node removal on process crash OR removal
+    - In the service, check our parent folder to see if we are in a screen (/machine-services/git/), and then write our nodeId to /machine-services/nodeId
+    - If we see a nodeId when we are removing a screen, or killing the service, then delete that nodeId from the nodeId directory (and call tellEveryoneNodesChanges)
 7.1) Verify this by killing a lot of services (the function runner?), by just poking it over and over, verifying the nodes are quickly deleted
 
 
 
 8) REIMPLEMENT yarn do-update functionality, with UI on the configuration page
+    OH, maybe... buttons for querysub, button for the main site, and then buttons on each service to update them!
+        YES, and then, a button to do all of that on each service, and a button to do that and on each service.
+        - So a lot of buttons. But only 2 components, one for all, and one for a specific service.
+    - Endpoints
+        - anyQuerysubUnsaved
+        - anyAppUnsaved
+        - querysubLatestHash
+        - appLatestHash (already have this)
+        - publish, add, commit, and push querysub (and update app package.json reference)
+        - add, commit and push app
+
     - On services list page, and individual service page
         - So... maybe the button a component
+        - MULTIPLE buttons, to just update the main site, just querysub, or both
     - Button to update on each service where the repoUrl === the repoUrl of the server
         - Only from a non-public server
     - ALSO, button to update all (that match repoUrl)

package/src/diagnostics/periodic.ts

@@ -1,4 +1,4 @@
-import { delay, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { delay, runInfinitePoll, runInfinitePollCallAtStart, shutdownPolling } from "socket-function/src/batching";
 import { isNode, timeInMinute } from "socket-function/src/misc";
 import { logErrors, timeoutToError } from "../errors";
 import debugbreak from "debugbreak";
@@ -37,26 +37,23 @@ export async function shutdown() {
     console.log(red("Starting shutdown"));
     shuttingDown = true;
     const { authorityStorage } = await import("../0-path-value-core/pathValueCore");
-    for (let fnc of preshutdownHandlers) {
-        try {
-            await timeoutToError(timeInMinute, fnc(), () => new Error(`Preshutdown handler ${fnc.name} timed out`));
-        } catch (e) {
-            console.log(`Error on preshutdown handler ${fnc.name}`, e);
-        }
+    try {
+        await Promise.allSettled([
+            ...preshutdownHandlers,
+        ].map(fnc => timeoutToError(timeInMinute, fnc(), () => new Error(`Preshutdown handler ${fnc.name} timed out`))));
+    } catch (e) {
+        console.log(`Error on preshutdown handlers`, e);
     }
     try {
-        await authorityStorage.onShutdown();
-        await nodeDiscoveryShutdown();
+        await Promise.allSettled([
+            function authorityStorageShutdown() { return authorityStorage.onShutdown(); },
+            nodeDiscoveryShutdown,
+            shutdownPolling,
+            ...shutdownHandlers,
+        ].map(fnc => timeoutToError(timeInMinute, fnc(), () => new Error(`Shutdown handler ${fnc.name} timed out`))));
     } catch (e) {
         console.log("Error on shutdown", e);
     }
-    for (let fnc of shutdownHandlers) {
-        try {
-            await timeoutToError(timeInMinute, fnc(), () => new Error(`Shutdown handler ${fnc.name} timed out`));
-        } catch (e) {
-            console.log(`Error on shutdown handler ${fnc.name}`, e);
-        }
-    }
     // Wait to allow any logged errors to hopefully be written somewhere?
     await delay(2000);
     process.exit();

package/src/library-components/ScrollOnMount.tsx

@@ -0,0 +1,19 @@
+import { qreact } from "../4-dom/qreact";
+export class ScrollOnMount extends qreact.Component<{ debugText: string }> {
+    scrolled = false;
+    render() {
+        return <div className={"ScrollOnMount"} ref={elem => {
+            if (!elem) return;
+            if (this.scrolled) return;
+            this.scrolled = true;
+            console.log(`Scrolled to ${this.props.debugText}`);
+            elem.scrollIntoView({ behavior: "instant", block: "center" });
+            // HACK: For some reason html has scroll (even though it's contents do not?).
+            //  So scrollIntoView might scroll it, which breaks things. So... reset it's scroll.
+            let htmlElement = document.body.parentElement;
+            if (htmlElement) {
+                htmlElement.scrollTop = 0;
+            }
+        }} />;
+    }
+}