querysub 0.407.0 → 0.408.0

package/src/1-path-client/RemoteWatcher.ts

@@ -6,7 +6,7 @@ import { isNode, sort } from "socket-function/src/misc";
 import { measureFnc, measureBlock } from "socket-function/src/profiling/measure";
 import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PathValueController } from "../0-path-value-core/PathValueController";
-import { PathRouter } from "../0-path-value-core/PathRouter";
+import { AuthoritySpec, PathRouter } from "../0-path-value-core/PathRouter";
 import { WatchConfig, authorityStorage } from "../0-path-value-core/pathValueCore";
 import { pathWatcher } from "../0-path-value-core/PathWatcher";
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
@@ -19,8 +19,9 @@ import { isDevDebugbreak } from "../config";
 import { auditLog, isDebugLogEnabled } from "../0-path-value-core/auditLogs";
 import { debugNodeThread } from "../-c-identity/IdentityController";
 import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
-import { decodeParentFilter, encodeParentFilter } from "../0-path-value-core/hackedPackedPathParentFiltering";
+import { decodeParentFilter, encodeParentFilter, registerGetSpecForChildPath } from "../0-path-value-core/hackedPackedPathParentFiltering";
 import { removeRange, rangesOverlap } from "../rangeMath";
+
 setImmediate(() => import("../4-querysub/Querysub"));
 
 // NOTE: In some cases this can half our the PathValues sent. AND, it can reduce our sync requests by N, and as those are uploads those are event more expensive. However, it also complicates other code, requiring not just checking if a value is synced, but also the parent path. We should try to make this stable, but worst case scenario, we can set this to false, and it will make our synchronization a lot easier to verify.
@@ -51,8 +52,8 @@ export class RemoteWatcher {
 
             // The authorityId satisifying this request
             authorityId: string;
+            authoritySpec: AuthoritySpec;
 
-            // All the paths that have getParentPathStr(path) === cleanPath, and PathRouter.getRouteChildKey is within start and end. We suppress these, as our parent watch implicitly watches them. HOWEVER, We have to track them So we can re-watch them if the parent watch is removed. 
             suppressedWatches: Set<string>;
         }[];
     }>());
@@ -132,6 +133,18 @@ export class RemoteWatcher {
     }
 
 
+    public getRemoteWatchParentRange(path: string) {
+        let parentPath = getParentPathStr(path);
+        let watchObj = this.remoteWatchParents2.get(parentPath);
+        if (!watchObj) return undefined;
+        // NOTE: PathRouter.getChildReadNodes PROMISES That all of the nodes will hash in the same way, and if they all hash in the same way, and they have different ranges, then every path will uniquely map to a single value. 
+        return watchObj.ranges.find(x => {
+            let route = PathRouter.getRouteFull({ path, spec: x.authoritySpec });
+            return x.start <= route && route < x.end;
+        });
+    }
+
+
     public debugIsWatchingPath(path: string) {
         // HACK: If there is no read node... pretend we are watching it. Because... for now, this is a known
         //  and the code calling this function isn't looking for that specific issue.
@@ -286,7 +299,6 @@ export class RemoteWatcher {
                         }
                         continue;
                     }
-
                 }
 
                 let { nodes } = PathRouter.getChildReadNodes(cleanPath, {
@@ -324,9 +336,11 @@ export class RemoteWatcher {
                 // NOTE: Nodes has no internal overlaps, and missing ranges by definition are only values that we haven't added (and itself has no overlaps). And so adding the intersection of those will also have no overlaps and only add values that we haven't added.
                 for (let missing of missingRanges) {
                     for (let node of nodes) {
+                        if (!rangesOverlap(node.range, missing)) continue;
+
                         let clippedStart = Math.max(node.range.start, missing.start);
                         let clippedEnd = Math.min(node.range.end, missing.end);
-                        if (clippedEnd - clippedStart <= 0) continue;
+
                         let finalPath = encodeParentFilter({ path: cleanPath, startFraction: clippedStart, endFraction: clippedEnd });
                         let existingRange = watchObj.ranges.find(x => x.finalPath === finalPath && x.authorityId === node.nodeId);
                         if (!existingRange) {
@@ -337,6 +351,7 @@ export class RemoteWatcher {
                                 inputPaths: new Set(),
                                 authorityId: node.nodeId,
                                 suppressedWatches: new Set(),
+                                authoritySpec: node.authoritySpec,
                             };
                             watchObj.ranges.push(existingRange);
                             let watchesPer = watchesPerAuthority.get(node.nodeId);
@@ -394,16 +409,13 @@ export class RemoteWatcher {
             if (STOP_KEYS_DOUBLE_SENDS) {
                 // NOTE: We could already be watching the value watches, in which case watching the parent watches will cause us to double watch them. This is fine. We don't need to remove all double watches. We just want to remove some. 
                 paths = paths.filter(path => {
-                    let cleanParent = getParentPathStr(path);
-                    let watchObj = this.remoteWatchParents2.get(cleanParent);
-                    if (!watchObj) return true;
-                    let routeKey = PathRouter.getRouteChildKey(path);
-                    // If we're watching it from any authority, don't watch it now. 
-                    let coveringRange = watchObj.ranges.find(x => x.start <= routeKey && routeKey < x.end);
-                    if (!coveringRange) return true;
-                    coveringRange.suppressedWatches.add(path);
-                    auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, remoteNodeId: authorityId });
-                    return false;
+                    let range = this.getRemoteWatchParentRange(path);
+                    if (range) {
+                        range.suppressedWatches.add(path);
+                        auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, remoteNodeId: authorityId });
+                        return false;
+                    }
+                    return true;
                 });
             }
 
@@ -583,18 +595,15 @@ export class RemoteWatcher {
         this.unwatchLatest(config);
     }
 
+    public async flushWatchers() {
+        await this.watchUnwatchSerial("flushWatchers", async () => { });
+    }
+
     @measureFnc
     public getExistingWatchRemoteNodeId(path: string): string | undefined {
-        let parentPath = getParentPathStr(path);
-        let parentWatchObj = this.remoteWatchParents2.get(parentPath);
-        if (parentWatchObj) {
-            let route = PathRouter.getRouteChildKey(path);
-            let range = parentWatchObj.ranges.find(x => x.start <= route && route < x.end);
-            if (range) {
-                return range.authorityId;
-            }
-            // NOTE: I think it is a bug if we hit here. There shouldn't be a parent, but have us not match it?
-            //  But... I also don't see the harm in checking remoteWatchPaths
+        let parentRange = this.getRemoteWatchParentRange(path);
+        if (parentRange) {
+            return parentRange.authorityId;
         }
         return this.remoteWatchPaths.get(path);
     }
@@ -665,6 +674,18 @@ export class RemoteWatcher {
     }
 }
 
+registerGetSpecForChildPath(path => {
+    if (!PathRouter.isSelfAuthority(path)) {
+        // Depends on the remote authority for this path
+        let remoteWatchRange = remoteWatcher.getRemoteWatchParentRange(path);
+        if (remoteWatchRange) return remoteWatchRange.authoritySpec;
+
+        // NOTE: This fall through usually means that we received a value before we started watching it, which is weird. That really shouldn't happen often. It'll probably break things. We will probably ignore this value thinking it has a different hash than it does.
+        console.warn(`We do not own a path, but also aren't watching it on a remote, but... receive the value? This is weird, and will probably break things (we will likely ignore this value / not trigger parent watches for it).`, { path });
+    }
+    return authorityLookup.getOurSpec();
+});
+
 export const remoteWatcher = new RemoteWatcher();
 (globalThis as any).remoteWatcher = remoteWatcher;
 void Promise.resolve().finally(() => {

package/src/4-querysub/Querysub.ts

@@ -285,10 +285,10 @@ export class Querysub {
      */
     @measureFnc
     public static async optionalStartupWait() {
+        await authorityLookup.startSyncing();
         await measureBlock(async () => {
             await waitForFirstTimeSync();
         }, "waitForFirstTimeSync");
-        await authorityLookup.startSyncing();
     }
 
     public static createWatcher(watcher: (obj: SyncWatcher) => void, options?: Partial<WatcherOptions<unknown>>): {
@@ -714,6 +714,10 @@ export class Querysub {
         })();
     }
 
+    private static socketFunctionInit() {
+        SocketFunction.addGlobalHook(() => authorityLookup.startSyncing());
+    }
+
     private static hostCalled = false;
     private static afterBootImports: string[] = [];
     /** NOTE: Imports occur one at a time, after the "clientsideEntryPoint", with each import waiting for the previous to finish.
@@ -744,6 +748,7 @@ export class Querysub {
         sourceCheck?: MachineSourceCheck<any>;
     }) {
         console.log(`Hosting server with config: ${JSON.stringify(config)}`);
+        this.socketFunctionInit();
 
         if (isClient()) {
             throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead.`);
@@ -1021,6 +1026,8 @@ export class Querysub {
         RequireController.addMapGetModules(async (result, args) => {
             let configObj = args[2] as { signedIdentity: SignedIdentity | undefined } | undefined;
             if (!await isAllowedToSeeSource(configObj?.signedIdentity)) {
+                require("debugbreak")(2);
+                debugger;
                 await isAllowedToSeeSource(configObj?.signedIdentity);
                 //console.log(red(`Not allowed to see source`));
                 for (let [key, value] of Object.entries(result.modules)) {
@@ -1038,6 +1045,7 @@ export class Querysub {
             throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead.`);
         }
 
+        this.socketFunctionInit();
         await SocketFunction.mount({
             public: isPublic(),
             port,
@@ -1062,10 +1070,14 @@ export class Querysub {
          */
         endFraction?: number;
     }): (keyof T)[] {
-        if (!isNode()) {
-            console.warn(`keys() is unlikely to work clientside. If we need to emulate how the server does the filtering, we should add an additional function to help with that. But there are issues with how query sub proxies watches, which make proxying partial key watches too difficult. ALSO, this is mostly for watching very large data streams with dynamic sharding (in FunctionRunner), and so shouldn't be needed clientside (the application can handle filtering at a schema level if it really wants something similar to this).`);
-        }
+
         let { startFraction, endFraction } = config || {};
+        if ((startFraction === undefined) !== (endFraction === undefined)) {
+            throw new Error(`startFraction and endFraction must both be provided, or both be undefined. If you want to get all keys, don't provide startFraction and endFraction.`);
+        }
+        if (!isNode() && startFraction !== undefined && endFraction !== undefined) {
+            console.warn(`keys() with a range restriction is not supported clientside. It's too complicated for the proxy to handle it because the hashing depends on the authority server. You can synchronize all the keys client side, but you can't synchronize a restriction of the keys.`);
+        }
         if (startFraction === undefined || endFraction === undefined) {
             return Object.keys(obj);
         }
@@ -1297,6 +1309,7 @@ setImmediate(async () => {
     // Import, so it registers addStatPeriodic
     await import("../5-diagnostics/nodeMetadata");
     await import("../diagnostics/pathAuditer");
+    await import("../diagnostics/NodeConnectionsPage");
 });
 
 setImmediate(async () => {
@@ -1312,7 +1325,6 @@ registerGetCompressNetwork(() => Querysub.COMPRESS_NETWORK);
 
 import "../diagnostics/watchdog";
 import "../diagnostics/trackResources";
-import "../diagnostics/benchmark";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { getCountPerPaint } from "../functional/onNextPaint";
 import { addEpsilons } from "../bits";

package/src/4-querysub/QuerysubController.ts

@@ -2,7 +2,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { cache, lazy } from "socket-function/src/caching";
 import { appendToPathStr, getPathDepth, getPathStr1, getPathStr3 } from "../path";
 import { FunctionMetadata } from "../3-path-functions/syncSchema";
-import { RemoteWatcher } from "../1-path-client/RemoteWatcher";
+import { RemoteWatcher, remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
 import { atomic, proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
 import { CallSpec, DEPTH_TO_DATA, commitCall, debugCallSpec, functionSchema, getDevFunctionSpecFromCall } from "../3-path-functions/PathFunctionRunner";
@@ -200,6 +200,7 @@ writeCall.value = async (callSpec: CallSpec, metadata: FunctionMetadata) => {
             });
 
             if (result === "run") {
+                obj.onApplied();
                 // NOTE: I think awaiting here is fine, as the the prediction blockers don't wait based on the right call finishing, and I don't think anything really waits for this to finish. 
                 await baseAddCall(callSpec);
             } else {
@@ -533,6 +534,7 @@ export class QuerysubControllerBase {
         pathWatcher.unwatchPath({ callback: callerId, ...config });
     }
 
+    // NOTE: Calls are going to be temporary and random. Any user can use any call ID, so technically you could clobber other users' call IDs, or your our. There wouldn't really be any benefit. Nothing would really happen if you do that, so I don't believe these need to be kept secret. I think if you know someone else's call ID you might be able to read that data, but also it's securely random, so you're not going to be able to guess the call ID.
     public async addCall(call: CallSpec) {
         if (isBootstrapOnly()) throw new Error(`Cannot add calls to bootstrap only server`);
         if (Querysub.DEBUG_CALLS) {
@@ -661,19 +663,28 @@ export class QuerysubControllerBase {
     }
 
 
+    public async debugGetPathNodeIds(paths: string[]): Promise<Map<string, string | "missing">> {
+        await remoteWatcher.flushWatchers();
+        let result = new Map<string, string | "missing">();
+        for (let path of paths) {
+            let nodeId = remoteWatcher.getExistingWatchRemoteNodeId(path) ?? PathRouter.getReadyAuthority(path)?.nodeId ?? "missing";
+            result.set(path, nodeId);
+        }
+        return result;
+    }
+
     // NOTE: Maybe remove this? It's very useful for debugging though...
     public async debugGetSingleReadNode(path: string) {
         return PathRouter.getReadyAuthority(path)?.nodeId;
     }
 
-    public async debugGetPathAuthorities(nodeId: string) {
-        let authorities = await authorityLookup.getTopology();
-        return authorities.find(x => x.nodeId === nodeId)?.authoritySpec;
-    }
-
-    public async debugGetTopologyEntry(nodeId: string) {
+    public async debugGetNodeSpecs(): Promise<Map<string, { routeStart: number; routeEnd: number }>> {
         let topology = await authorityLookup.getTopology();
-        return topology.find(x => x.nodeId === nodeId);
+        let result = new Map<string, { routeStart: number; routeEnd: number }>();
+        for (let entry of topology) {
+            result.set(entry.nodeId, { routeStart: entry.authoritySpec.routeStart, routeEnd: entry.authoritySpec.routeEnd });
+        }
+        return result;
     }
 }
 
@@ -685,9 +696,9 @@ export const QuerysubController = SocketFunction.register(
         watch: { compress: true, },
         unwatch: { compress: true, },
         addCall: { compress: true, },
+        debugGetPathNodeIds: {},
+        debugGetNodeSpecs: {},
         debugGetSingleReadNode: {},
-        debugGetPathAuthorities: {},
-        debugGetTopologyEntry: {},
         getModulePath: {},
         getDevFunctionSpecFromCall: {},
     }),

package/src/4-querysub/predictionQueue.tsx

@@ -156,6 +156,9 @@ export async function runInPredictionQueue(config: {
 
     // Resolve all the values before us as well, before even our own promise, and then wait on that promise. That way, everything finishes in the same order it starts. 
     if (index >= 0) {
+        if (index > 1) {
+            console.log(`Flushing ${index} other calls due to ${callSpec.FunctionId}`);
+        }
         for (let i = 0; i <= index; i++) {
             commitQueue[i].resolveOrderedPromise.resolve();
         }

package/src/4-querysub/querysubPrediction.ts

@@ -8,7 +8,6 @@ import { getModuleFromConfig, setGitURLMapping } from "../3-path-functions/pathF
 import { logErrors } from "../errors";
 import { getPathFromStr, getPathStr1 } from "../path";
 import { Querysub, QuerysubController, QuerysubControllerBase, registerPredictionBlocker, querysubNodeId } from "./QuerysubController";
-import { Benchmark } from "../diagnostics/benchmark";
 import { parseArgs } from "../3-path-functions/PathFunctionHelpers";
 import { magenta, red } from "socket-function/src/formatting/logColors";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
@@ -21,6 +20,7 @@ import { isPublic } from "../config";
 import { clientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { cacheAsyncLimitedJSON } from "../functional/promiseCache";
 import { addEpsilons } from "../bits";
+import { delay } from "socket-function/src/batching";
 setFlag(require, "cbor-x", "allowclient", true);
 const cborEncoder = lazy(() => new cbor.Encoder({ structuredClone: true }));
 
@@ -90,13 +90,15 @@ const predictRunCommitLoop = (run: () => Promise<PredictResult | undefined>) =>
 
 // IMPORTANT! This has to be synchronous, and we need to synchronously get into the proxy watcher call. That way other calls after this know to wait for our proxy watcher to finish. Otherwise, it's very, very, very easy to write code, where you call a function, you expect it to write to a value, and then you run some other code, maybe which just uses a commit async, and tries to read from that value. But the value won't exist, because we won't even have started the prediction yet, and the proxy watcher can't possibly know to wait, because we haven't started the prediction. So... this has to be synchronous!
 export function predictCall(call: CallSpec, metadata: FunctionMetadata): {
+    onApplied: () => void;
     cancel: () => void;
     predictPromise: Promise<PredictResult | undefined>;
 } {
     let predictObj = predictCallBase({ call, metadata });
     let cancel = predictObj.cancel;
+    let onApplied = predictObj.onApplied;
     registerPredictionBlocker(call.CallId, predictObj.predictPromise);
-    return { cancel, predictPromise: predictObj.predictPromise };
+    return { cancel, onApplied, predictPromise: predictObj.predictPromise };
 }
 
 function getPredictTime(time: Time) {
@@ -115,12 +117,33 @@ function predictCallBase(config: {
     metadata: FunctionMetadata;
     overrides?: PathValue[];
 }): {
+    onApplied: () => void;
     cancel: () => void;
     predictPromise: Promise<PredictResult | undefined>;
 } {
     let call = config.call;
     let pathResultWrite = getCallResultPath(call);
-    Benchmark.onStartPredictCall(pathResultWrite);
+
+    let actualValueFinished = new PromiseObj();
+    function onActualFinished() {
+        if (actualValueFinished.resolveCalled) return;
+        let resultObj = authorityStorage.getValueAtTime(pathResultWrite, undefined);
+        let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
+        if (!result) return;
+        if (result.lastInternalLoopCount === -1) return;
+        actualValueFinished.resolve();
+        for (let callback of onPredictionFinishedCallbacks) {
+            callback({ callId: call.CallId, result, functionId: call.FunctionId });
+        }
+    }
+    function onApplied() {
+        clientWatcher.setWatches({
+            callback: onActualFinished,
+            paths: new Set([pathResultWrite]),
+            parentPaths: new Set(),
+        });
+    }
+
     let functionResult: FunctionResult = {
         // Special prediction values (we don't even really need to put anything here, but it
         //  might as well have the right format, in case a bug causes it to be used somewhere)
@@ -183,23 +206,6 @@ function predictCallBase(config: {
             readParentPaths: Set<string>;
         };
 
-        let actualValueFinished = new PromiseObj();
-        function onActualFinished() {
-            let resultObj = authorityStorage.getValueAtTime(pathResultWrite, undefined);
-            let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
-            if (!result) return;
-            if (result.lastInternalLoopCount === -1) return;
-            actualValueFinished.resolve();
-            for (let callback of onPredictionFinishedCallbacks) {
-                callback({ callId: call.CallId, result, functionId: call.FunctionId });
-            }
-        }
-        clientWatcher.setWatches({
-            callback: onActualFinished,
-            paths: new Set([pathResultWrite]),
-            parentPaths: new Set(),
-        });
-
         setTimeout(() => {
             clientWatcher.unwatch(onActualFinished);
         }, 30 * 1000);
@@ -360,6 +366,7 @@ function predictCallBase(config: {
     return {
         cancel: rejectPrediction,
         predictPromise,
+        onApplied,
     };
 }
 

package/src/5-diagnostics/nodeMetadata.ts

@@ -13,6 +13,7 @@ import { isNode } from "typesafecss";
 import { devDebugbreak } from "../config";
 import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, onTimeProfile, logNodeStats, logNodeStateStats, registerNodeMetadata } from "../-0-hooks/hooks";
 import { magenta } from "socket-function/src/formatting/logColors";
+import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
 
 
 let POLL_INTERVAL = timeInMinute * 5;
@@ -295,6 +296,16 @@ class NodeMetadataBase {
             };
         }));
     }
+
+    public async debugGetPathAuthorities(nodeId: string) {
+        let authorities = await authorityLookup.getTopology();
+        return authorities.find(x => x.nodeId === nodeId)?.authoritySpec;
+    }
+
+    public async debugGetTopologyEntry(nodeId: string) {
+        let topology = await authorityLookup.getTopology();
+        return topology.find(x => x.nodeId === nodeId);
+    }
 }
 export const NodeMetadataController = SocketFunction.register(
     "NodeMetadataController-8be51a16-27c2-449e-b044-dcef6c3efcaf",
@@ -303,5 +314,11 @@ export const NodeMetadataController = SocketFunction.register(
         getExtraMetadatas: {
             hooks: [requiresNetworkTrustHook],
         },
+        debugGetPathAuthorities: {
+            hooks: [requiresNetworkTrustHook],
+        },
+        debugGetTopologyEntry: {
+            hooks: [requiresNetworkTrustHook],
+        },
     }),
 );

package/src/diagnostics/NodeConnectionsPage.tsx

@@ -0,0 +1,167 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../4-dom/qreact";
+import { assertIsManagementUser } from "./managementPages";
+import { css } from "typesafecss";
+import { getSyncedController } from "../library-components/SyncedController";
+import { getAllNodeIds, getBrowserUrlNode } from "../-f-node-discovery/NodeDiscovery";
+import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
+import { debugNodeId } from "../-c-identity/IdentityController";
+import { fastHash } from "../misc/hash";
+import { NodeCapabilitiesController } from "../-g-core-values/NodeCapabilities";
+import { sort } from "socket-function/src/misc";
+
+
+
+function getColorForNodeId(friendlyNodeId: string): string {
+    let hash = fastHash(friendlyNodeId);
+    let hue = hash % 360;
+    return `hsl(${hue}, 70%, 60%)`;
+}
+
+export class NodeConnectionsPage extends qreact.Component {
+    render() {
+        let browserNode = getBrowserUrlNode();
+        let controller = nodeConnectionsController(browserNode);
+
+        let nodeIds = controller.getAllNodeIds();
+        if (!nodeIds) {
+            return <div class={css.pad2(10)}>Loading...</div>;
+        }
+
+        let connectableNodes: Array<{ nodeId: string; friendlyNodeId: string; entryPoint: string | undefined; connections: Array<{ nodeId: string; friendlyNodeId: string }> }> = [];
+        let nonConnectableNodes: string[] = [];
+
+        for (let nodeId of nodeIds) {
+            try {
+                let result = controller.getNodeConnections_forBrowser(nodeId);
+                if (result) {
+                    let friendlyNodeId = debugNodeId(nodeId);
+                    let entryPoint: string | undefined;
+                    try {
+                        entryPoint = controller.getEntryPoint_forBrowser(nodeId);
+                    } catch (e) {
+                        entryPoint = undefined;
+                    }
+                    connectableNodes.push({
+                        nodeId,
+                        friendlyNodeId,
+                        entryPoint,
+                        connections: result.connections,
+                    });
+                }
+            } catch (e) {
+                nonConnectableNodes.push(nodeId);
+            }
+        }
+
+        return (
+            <div class={css.pad2(10).vbox(20).fillWidth}>
+                <div class={css.vbox(10).fillWidth}>
+                    <h1>Connectable Nodes</h1>
+                    {connectableNodes.map(node => {
+                        let color = getColorForNodeId(node.friendlyNodeId);
+                        return (
+                            <div class={css.vbox(5).pad2(10).maxHeight(600).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
+                                <div class={css.vbox(3)}>
+                                    {node.entryPoint && (
+                                        <div class={css.fontSize(14).fontWeight("bold")}>
+                                            {node.entryPoint}
+                                        </div>
+                                    )}
+                                    <div class={css.hbox(5)}>
+                                        <span class={css.background(color).pad2(4, 2).fontWeight("bold")}>
+                                            {node.friendlyNodeId}
+                                        </span>
+                                        <span class={css.color("gray").fontSize(12)}>
+                                            ({node.nodeId})
+                                        </span>
+                                    </div>
+                                </div>
+                                <div class={css.vbox(3).paddingLeft(20)}>
+                                    {node.connections.length === 0 && (
+                                        <div class={css.color("gray")}>No connections</div>
+                                    )}
+                                    {node.connections.map(conn => {
+                                        let connColor = getColorForNodeId(conn.friendlyNodeId);
+                                        return (
+                                            <div class={css.hbox(5)}>
+                                                <span>→ Connected to:</span>
+                                                <span class={css.background(connColor).pad2(4, 2).fontWeight("bold")}>
+                                                    {conn.friendlyNodeId}
+                                                </span>
+                                                <span class={css.color("gray").fontSize(12)}>
+                                                    ({conn.nodeId})
+                                                </span>
+                                            </div>
+                                        );
+                                    })}
+                                </div>
+                            </div>
+                        );
+                    })}
+                </div>
+
+                <div class={css.vbox(10).fillWidth}>
+                    <h1>Non-Connectable Nodes</h1>
+                    <div class={css.vbox(5).pad2(10).maxHeight(600).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
+                        {nonConnectableNodes.map(nodeId => {
+                            let friendlyNodeId = debugNodeId(nodeId);
+                            return (
+                                <div class={css.hbox(5)}>
+                                    <span class={css.background("lightgray").pad2(4, 2).fontWeight("bold")}>
+                                        {friendlyNodeId}
+                                    </span>
+                                    <span class={css.color("gray").fontSize(12)}>
+                                        ({nodeId})
+                                    </span>
+                                    <span class={css.color("gray")}>- Can't connect</span>
+                                </div>
+                            );
+                        })}
+                    </div>
+                </div>
+            </div>
+        );
+    }
+}
+
+class NodeConnectionsControllerBase {
+    public async getNodeConnections() {
+        let factories = debugGetAllCallFactories();
+        let connections = factories.filter(x => x.isConnected).map(factory => ({
+            nodeId: factory.nodeId,
+            friendlyNodeId: debugNodeId(factory.nodeId),
+        }));
+        return { connections };
+    }
+
+    public async getNodeConnections_forBrowser(nodeId: string) {
+        let result = await NodeConnectionsController.nodes[nodeId].getNodeConnections();
+        sort(result.connections, x => x.friendlyNodeId);
+        return result;
+    }
+
+    public async getEntryPoint_forBrowser(nodeId: string) {
+        return await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+    }
+
+    public async getAllNodeIds() {
+        return await getAllNodeIds();
+    }
+}
+
+export const NodeConnectionsController = SocketFunction.register(
+    "NodeConnectionsController-8f3e2a1b-4c5d-4f2e-9a3b-7c8d1e2f3a4b",
+    new NodeConnectionsControllerBase(),
+    () => ({
+        getNodeConnections: {},
+        getNodeConnections_forBrowser: {},
+        getEntryPoint_forBrowser: {},
+        getAllNodeIds: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    })
+);
+
+export const nodeConnectionsController = getSyncedController(NodeConnectionsController);