querysub 0.451.0 → 0.452.0

package/src/-g-core-values/NodeCapabilities.ts

@@ -12,6 +12,7 @@ import { delay } from "socket-function/src/batching";
 import debugbreak from "debugbreak";
 import { formatTime } from "socket-function/src/formatting/format";
 import type { DebugFunctionShardInfo } from "../3-path-functions/PathFunctionRunner";
+import type { AuthoritySpec } from "../0-path-value-core/PathRouter";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { isNoNetwork } from "../config";
 import { getDebuggerUrl } from "../diagnostics/listenOnDebugger";
@@ -94,10 +95,10 @@ export async function getControllerNodeIdList(
     await Promise.all(nodeIdsToTest.map(async nodeId => {
         let result = await doesNodeExposeController(nodeId, controller);
         if (result) {
-            let entryPoint = await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+            let metadata = await NodeCapabilitiesController.nodes[nodeId].getMetadata();
             passedNodeIds.set(nodeId, {
                 machineId: getMachineId(nodeId),
-                entryPoint,
+                entryPoint: metadata.entryPoint,
             });
         }
     }));
@@ -117,38 +118,43 @@ export async function getControllerNodeIdList(
 
 
 export async function doesNodeExposeController(reconnectNodeId: string, controller: SocketRegistered<{}>): Promise<boolean> {
-    let exposedControllers = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[reconnectNodeId].getExposedControllers());
+    let metadata = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[reconnectNodeId].getMetadata());
 
-    if (exposedControllers?.includes(controller._classGuid)) {
+    if (metadata?.exposedControllers.includes(controller._classGuid)) {
         return true;
     }
     return false;
 }
 
 const startupTime = Date.now();
+
+export type NodeMetadata = {
+    entryPoint: string;
+    startupTime: number;
+    processId: number;
+    functionRunnerShards: DebugFunctionShardInfo[];
+    authoritySpec: AuthoritySpec;
+    exposedControllers: string[];
+    trueTimeOffset: number;
+};
+
 class NodeCapabilitiesControllerBase {
-    public async getExposedControllers() {
-        return Array.from(SocketFunction.exposedClasses);
-    }
-    public async getEntryPoint() {
-        return process.argv[1];
-    }
-    public async getStartupTime() {
-        return startupTime;
+    public async getMetadata(): Promise<NodeMetadata> {
+        let { authorityLookup } = await import("../0-path-value-core/AuthorityLookup");
+        return {
+            entryPoint: process.argv[1],
+            startupTime,
+            processId: process.pid,
+            functionRunnerShards: getFunctionRunnerShards(),
+            authoritySpec: authorityLookup.getOurSpec(),
+            exposedControllers: Array.from(SocketFunction.exposedClasses),
+            trueTimeOffset: getTrueTimeOffset(),
+        };
     }
+
     public async getMemoryUsage() {
         return process.memoryUsage();
     }
-    public async getProcessId() {
-        return process.pid;
-    }
-    public async getFunctionRunnerShards() {
-        return getFunctionRunnerShards();
-    }
-
-    public async getTrueTimeOffset() {
-        return getTrueTimeOffset();
-    }
 
     public async getInspectURL() {
         return await getDebuggerUrl();
@@ -188,13 +194,8 @@ export const NodeCapabilitiesController = SocketFunction.register(
     "NodeCapabilitiesController-399b7067-75c3-4d92-8be3-8470bde32d3c",
     new NodeCapabilitiesControllerBase(),
     () => ({
-        getExposedControllers: {},
-        getEntryPoint: {},
-        getStartupTime: {},
+        getMetadata: {},
         getMemoryUsage: {},
-        getProcessId: {},
-        getFunctionRunnerShards: {},
-        getTrueTimeOffset: {},
         getInspectURL: { hooks: [requiresNetworkTrustHook] },
         exposeExternalDebugPortOnce: { hooks: [requiresNetworkTrustHook] },
     }),

package/src/0-path-value-core/archiveLocks/ArchiveLocks2.ts

@@ -245,7 +245,31 @@ export function createArchiveLocker2(config: {
                     newTransaction.ops.push({ type: "delete", key: obj.file });
                 }
             }
+            // Per-op trace so a "written too slowly" crash on a specific file can be
+            //  correlated against the exact transaction that touched it. The aggregate
+            //  "Joining N => M" log doesn't name the files. We log before the attempt and
+            //  again after with the resulting status (including "rejected").
+            const describeOp = (op: typeof newTransaction.ops[number]): string => {
+                let detail = "";
+                if (op.key.endsWith(".data") || op.key.endsWith(".data.locked")) {
+                    try {
+                        detail = ` source=${pathValueArchives.decodeDataPath(op.key).sourceType}`;
+                    } catch (e) {
+                        detail = ` decodeError=${(e as Error).message ?? e}`;
+                    }
+                }
+                return `${op.type} ${op.key}${detail}`;
+            };
+            for (let op of newTransaction.ops) {
+                console.info(`Transaction attempt: ${describeOp(op)}`);
+            }
+
             let status = await locker.addTransaction(newTransaction);
+
+            for (let op of newTransaction.ops) {
+                console.info(`Transaction ${status}: ${describeOp(op)}`);
+            }
+
             if (status === "accepted") {
                 let newFiles = new Set<string>();
                 for (let file of files) {

package/src/0-path-value-core/pathValueCore.ts

@@ -68,7 +68,7 @@ export const MAX_CHANGE_AGE = MAX_ACCEPTED_CHANGE_AGE * 2;
 /** Extra time we keep clientside prediction rejections for, to give us time to receive the actual values. */
 export const CLIENTSIDE_PREDICT_LEEWAY = 500;
 
-/** Any PathValues which take longer than this to wrist should be rejected, so... we have
+/** Any PathValues which take longer than this to write should be rejected, so... we have
  *      to write well before this time.
  *      - This has to be at least MAX_CHANGE_AGE * 4.5 + the time to serialize and
  *          send our data to remote storage.

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1472,8 +1472,8 @@ export class PathValueProxyWatcher {
                                 let notWatchingUnsyncedParent = reallyUnsyncedParentAccesses.filter(x => !remoteWatcher.debugIsWatchingPath(x));
                                 if (notWatchingUnsynced.length !== 0 || notWatchingUnsyncedParent.length !== 0) {
                                     console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("NOT REMOTE WATCHING REQUIRED PATHS")}. This means our sync or unsync (likely unsync) logic is broken, in remoteWatcher/clientWatcher. OR, there were no read nodes when we tried to sync (we don't handle missing read nodes correctly at the moment)`), { notWatchingUnsynced, notWatchingUnsyncedParent }, watcher.options.watchFunction);
-                                    debugbreak(2);
-                                    debugger;
+                                    // debugbreak(2);
+                                    // debugger;
                                 } else {
                                     console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT RECEIVE PATH VALUES")}. This means PathValueServer is not responding to watches, either to specific paths, or for all paths`), { reallyUnsyncedAccesses, reallyUnsyncedParentAccesses }, watcher.options.watchFunction);
                                     // debugbreak(2);
@@ -1481,12 +1481,12 @@ export class PathValueProxyWatcher {
                                 }
                             } else if (watcher.lastSpecialPromiseUnsynced) {
                                 console.warn((`${yellow("WATCHER SLOW TO SYNC")} ${watcher.debugName} ${magenta("DEPENDENT PROMISE NEVER RESOLVED")}. This promise might resolve, but it probably won't. Slow promises should be detached from the watcher system and use multiple watchers/writes, instead of blocking on a promise.`), watcher.lastSpecialPromiseUnsyncedReason, watcher.options.watchFunction);
-                                debugbreak(2);
-                                debugger;
+                                // debugbreak(2);
+                                // debugger;
                             } else {
                                 console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT TRIGGER WATCHER")}. This means either ProxyWatcher is broken (and isn't triggering when it should, or isn't watching when it should), or ClientWatcher/PathWatcher are broken and are not properly informing callers of watchers.`), { lastUnsyncedAccesses: watcher.lastUnsyncedAccesses, lastUnsyncedParentAccesses: watcher.lastUnsyncedParentAccesses }, watcher.options.watchFunction);
-                                debugbreak(2);
-                                debugger;
+                                // debugbreak(2);
+                                // debugger;
                             }
                         }, 60000);
                     }

package/src/archiveapps/archiveGCEntry.tsx

@@ -29,6 +29,7 @@ async function main() {
     await Querysub.hostService("gc");
 
     if (yargObj.watch) {
+        console.log("Running in watch mode.");
         await runInfinitePollCallAtStart(timeInDay, runAliveCheckerIteration);
     } else {
         try {

package/src/archiveapps/archiveJoinEntry.ts

@@ -2,7 +2,7 @@ import "../inject";
 
 import { logErrors } from "../errors";
 import { PathValueArchives, pathValueArchives } from "../0-path-value-core/pathValueArchives";
-import { PathValue, VALUE_GC_THRESHOLD } from "../0-path-value-core/pathValueCore";
+import { ARCHIVE_FLUSH_LIMIT, PathValue, VALUE_GC_THRESHOLD } from "../0-path-value-core/pathValueCore";
 import { runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { measureBlock } from "socket-function/src/profiling/measure";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
@@ -41,7 +41,12 @@ async function runGenesisJoinIteration(config?: { force?: boolean }) {
                 valueFiles = valueFiles.filter(x => {
                     let obj = pathValueArchives.decodeDataPath(x.file);
                     if (!obj.minTime) return false;
-                    return obj.sourceType === "genesis";
+                    if (obj.sourceType === "genesis") {
+                        // Has to be old enough
+                        return Date.now() - obj.time < ARCHIVE_FLUSH_LIMIT;
+                    }
+                    // Anything else can be merged immediately.
+                    return true;
                 });
             }
             let withinTimeRangeCount = valueFiles.length;
@@ -123,6 +128,7 @@ async function main() {
     await Querysub.hostService("join");
 
     if (yargObj.watch) {
+        console.log("Running in watch mode.");
         await runInfinitePollCallAtStart(VALUE_GC_THRESHOLD * 0.8, runGenesisJoinIteration);
     } else {
         try {

package/src/deployManager/LaunchTrackingHeader.tsx

@@ -0,0 +1,69 @@
+module.allowclient = true;
+
+import { qreact } from "../4-dom/qreact";
+import { css } from "typesafecss";
+import { getBrowserUrlNode } from "../-f-node-discovery/NodeDiscovery";
+import { MachineServiceController } from "./machineSchema";
+
+const SINCE_DAYS = 7;
+const CRASH_HUE = 0;
+const OTHER_HUE = 210;
+
+export class LaunchTrackingHeader extends qreact.Component {
+    render() {
+        let summaries = MachineServiceController(getBrowserUrlNode()).getRecentLaunches(SINCE_DAYS);
+        if (!summaries) return undefined;
+        if (summaries.length === 0) return undefined;
+
+        let totalCrashes = 0;
+        let totalOther = 0;
+        let perKey = new Map<string, { crashes: number; other: number }>();
+        for (let s of summaries) {
+            let isCrash = s.reason === "crashed";
+            if (isCrash) totalCrashes++;
+            else totalOther++;
+            let entry = perKey.get(s.serviceKey);
+            if (!entry) {
+                entry = { crashes: 0, other: 0 };
+                perKey.set(s.serviceKey, entry);
+            }
+            if (isCrash) entry.crashes++;
+            else entry.other++;
+        }
+
+        let top: { serviceKey: string; crashes: number; other: number } | undefined;
+        for (let [serviceKey, c] of perKey) {
+            let candidate = { serviceKey, crashes: c.crashes, other: c.other };
+            if (!top) {
+                top = candidate;
+                continue;
+            }
+            if (candidate.crashes > top.crashes) {
+                top = candidate;
+            } else if (candidate.crashes === top.crashes && (candidate.crashes + candidate.other) > (top.crashes + top.other)) {
+                top = candidate;
+            }
+        }
+
+        let title = `Launches in last ${SINCE_DAYS} days: ${totalCrashes} crashed, ${totalOther} other`;
+        if (top && top.crashes > 0) {
+            title += ` -- top by crashes: ${top.serviceKey} (${top.crashes} crashed, ${top.other} other)`;
+        }
+
+        return <div title={title} className={css.hbox(6).colorhsl(0, 0, 20)}>
+            <span>🚀</span>
+            <span>
+                <span className={css.colorhsl(CRASH_HUE, 70, 35).boldStyle}>{totalCrashes}</span>
+                <span className={css.colorhsl(0, 0, 55)}>|</span>
+                <span className={css.colorhsl(OTHER_HUE, 65, 35).boldStyle}>{totalOther}</span>
+            </span>
+            {top && top.crashes > 0 &&
+                <span className={css.colorhsl(0, 0, 40)}>
+                    (<span className={css.colorhsl(CRASH_HUE, 70, 35)}>{top.crashes}</span>
+                    <span className={css.colorhsl(0, 0, 55)}>|</span>
+                    <span className={css.colorhsl(OTHER_HUE, 65, 35)}>{top.other}</span>)
+                </span>
+            }
+        </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 { forceRemoveNode, getOurNodeId, getOurNodeIdAssert } from "../-f-node-discovery/NodeDiscovery";
 import { Querysub } from "../4-querysub/QuerysubController";
-import { MACHINE_RESYNC_INTERVAL, MachineServiceControllerBase, MachineInfo, ServiceConfig, serviceConfigs, SERVICE_FOLDER, machineInfos, SERVICE_NODE_FILE_NAME, getEffectiveServiceConfigs } from "./machineSchema";
+import { MACHINE_RESYNC_INTERVAL, MachineServiceControllerBase, MachineInfo, ServiceConfig, serviceConfigs, SERVICE_FOLDER, machineInfos, SERVICE_NODE_FILE_NAME, getEffectiveServiceConfigs, recordLaunch } from "./machineSchema";
 import { runPromise } from "../functional/runCommand";
 import { getExternalIP } from "socket-function/src/networking";
 import { errorToUndefined, errorToUndefinedSilent } from "../errors";
@@ -183,25 +183,21 @@ export async function streamScreenOutput(config: {
             const pipeFile = `${root}${screenName}/pipe.txt`;
             const tailScript = `${root}${screenName}/smart_tail.sh`;
 
-            // Create a smart tail script that handles file truncation
+            // Create a smart tail script that handles file truncation. It does
+            // NOT emit the initial backlog - that is read and sent directly by
+            // this process (as a single message) below. The script is given a
+            // start byte offset and only emits content appended after it.
             await fs.promises.writeFile(tailScript, `#!/bin/bash
 PIPE_FILE="$1"
+START_POS="$2"
 
-# Initialize position tracking
-CURRENT_POS=0
+# Position tracking starts at the offset we already read directly.
+CURRENT_POS=$START_POS
+CURRENT_SIZE=$START_POS
 LAST_MTIME=""
 
-# Read initial content and get file size
 if [ -f "$PIPE_FILE" ]; then
-    CURRENT_SIZE=$(stat -c%s "$PIPE_FILE" 2>/dev/null || wc -c < "$PIPE_FILE")
     LAST_MTIME=$(stat -c%Y "$PIPE_FILE" 2>/dev/null || stat -f%m "$PIPE_FILE" 2>/dev/null || echo "0")
-    # Output initial content like tail would
-    if [ $CURRENT_SIZE -gt 0 ]; then
-        cat "$PIPE_FILE"
-        CURRENT_POS=$CURRENT_SIZE
-    fi
-else
-    CURRENT_SIZE=0
 fi
 
 # Poll for file changes every 250ms
@@ -237,8 +233,21 @@ done`);
 
             await runPromise(`chmod +x ${tailScript}`);
 
-            // Use our smart tail script instead of regular tail
-            childProcess = spawn("bash", [tailScript, pipeFile], {
+            // Read the existing backlog ourselves and deliver it as a single
+            // onData call. If we let the tail script cat it, the stream chunks
+            // it and runInSerial dribbles it out one round-trip at a time.
+            let initialContent = "";
+            let initialByteSize = 0;
+            try {
+                initialContent = await fs.promises.readFile(pipeFile, "utf8");
+                initialByteSize = Buffer.byteLength(initialContent, "utf8");
+            } catch {
+                // pipe.txt may not exist yet; the tail script will pick it up.
+            }
+
+            // The tail script emits only content appended after initialByteSize,
+            // so the backlog we just read is never sent twice.
+            childProcess = spawn("bash", [tailScript, pipeFile, String(initialByteSize)], {
                 stdio: "pipe",
             });
 
@@ -262,6 +271,13 @@ done`);
                 started.reject(err);
             });
 
+            if (initialContent) {
+                // Queued synchronously here, before any stdout 'data' event can
+                // fire, so the backlog is always delivered ahead of new output.
+                started.resolve();
+                void onDataWrapped(initialContent);
+            }
+
             await started.promise;
         } catch (e) {
             void stop();
@@ -725,6 +741,21 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
 
                 await fs.promises.writeFile(parameterPath, newParametersString);
 
+                let launchReason: "crashed" | "update";
+                if (!sameParameters) {
+                    launchReason = "update";
+                } else {
+                    launchReason = "crashed";
+                }
+                void recordLaunch({
+                    serviceId: config.serviceId,
+                    serviceKey: config.parameters.key,
+                    screenName,
+                    machineId,
+                    reason: launchReason,
+                    time: Date.now(),
+                });
+
                 await runScreenCommand({
                     screenName,
                     command: config.parameters.command,

package/src/deployManager/machineSchema.ts

@@ -1,4 +1,4 @@
-import { isNodeTrue, list, timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { isNodeTrue, list, timeInDay, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { nestArchives } from "../-a-archives/archives";
 import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
 import { getDomain } from "../config";
@@ -103,6 +103,69 @@ export const machineInfos = archiveJSONT<MachineInfo>(() => nestArchives("machin
 export const serviceConfigs = archiveJSONT<ServiceConfig>(() => nestArchives("machines/service-configs/", getArchivesBackblaze(getDomain())));
 export const machineConfigs = archiveJSONT<MachineConfig>(() => nestArchives("machines/machine-configs/", getArchivesBackblaze(getDomain())));
 
+export type LaunchRecord = {
+    serviceId: string;
+    serviceKey: string;
+    screenName: string;
+    machineId: string;
+    reason: "crashed" | "update";
+    time: number;
+};
+
+export type LaunchSummary = {
+    time: number;
+    reason: string;
+    serviceKey: string;
+    key: string;
+};
+
+const launches = lazy(() => nestArchives("machines/launches/", getArchivesBackblaze(getDomain())));
+
+function formatLaunchDay(time: number): string {
+    let date = new Date(time);
+    let y = date.getUTCFullYear();
+    let m = String(date.getUTCMonth() + 1).padStart(2, "0");
+    let d = String(date.getUTCDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+}
+
+export async function recordLaunch(record: LaunchRecord) {
+    let day = formatLaunchDay(record.time);
+    let key = `${day}/${record.time}_${record.reason}_${record.serviceKey}`;
+    await launches().set(key, Buffer.from(JSON.stringify(record)));
+}
+
+function parseLaunchKey(key: string): LaunchSummary {
+    let rest = key;
+    let slash = key.indexOf("/");
+    if (slash >= 0) {
+        rest = key.slice(slash + 1);
+    }
+    let timeStr = "";
+    let afterTime = rest;
+    let firstUnderscore = rest.indexOf("_");
+    if (firstUnderscore >= 0) {
+        timeStr = rest.slice(0, firstUnderscore);
+        afterTime = rest.slice(firstUnderscore + 1);
+    }
+    let reason = afterTime;
+    let serviceKey = "";
+    let secondUnderscore = afterTime.indexOf("_");
+    if (secondUnderscore >= 0) {
+        reason = afterTime.slice(0, secondUnderscore);
+        serviceKey = afterTime.slice(secondUnderscore + 1);
+    }
+    let time = Number(timeStr);
+    if (!Number.isFinite(time)) {
+        console.warn(`Unparseable launch key (bad time): ${key}`);
+        time = Date.now();
+    }
+    if (reason !== "crashed" && reason !== "update") {
+        console.warn(`Launch key has unexpected reason "${reason}": ${key}`);
+    }
+    return { time, reason, serviceKey, key };
+}
+
 export function doRegisterNodeForMachineCleanup() {
     if (isNode()) {
         void SocketFunction.mountPromise.finally(() => {
@@ -371,6 +434,22 @@ export class MachineServiceControllerBase {
         });
     }
 
+    public async getRecentLaunches(sinceDays: number): Promise<LaunchSummary[]> {
+        let now = Date.now();
+        let dayStrings: string[] = [];
+        for (let i = 0; i <= sinceDays; i++) {
+            dayStrings.push(formatLaunchDay(now - i * timeInDay));
+        }
+        let keyLists = await Promise.all(dayStrings.map(day => launches().find(`${day}/`)));
+        let summaries: LaunchSummary[] = [];
+        for (let keys of keyLists) {
+            for (let key of keys) {
+                summaries.push(parseLaunchKey(key));
+            }
+        }
+        return summaries;
+    }
+
     public async deployFunctions(config: {
         functionSpecs: FunctionSpec[];
         prefixes: string[];
@@ -469,6 +548,7 @@ export const MachineServiceController = getSyncedController(
             getPendingFunctions: {},
             deployFunctions: {},
             getLiveFunctions: {},
+            getRecentLaunches: {},
         }),
         () => ({
             hooks: [assertIsManagementUser],
@@ -497,6 +577,7 @@ export const MachineServiceController = getSyncedController(
             getGitInfo: ["gitInfo"],
             getPendingFunctions: ["gitInfo"],
             getLiveFunctions: ["gitInfo"],
+            getRecentLaunches: ["launches"],
         }
     }
 );

package/src/diagnostics/NodeConnectionsPage.tsx

@@ -142,7 +142,7 @@ class NodeConnectionsControllerBase {
     }
 
     public async getEntryPoint_forBrowser(nodeId: string) {
-        return await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+        return (await NodeCapabilitiesController.nodes[nodeId].getMetadata()).entryPoint;
     }
 
     public async getAllNodeIds() {

package/src/diagnostics/NodeViewer.tsx

@@ -79,10 +79,11 @@ export class NodeViewer extends qreact.Component {
                     let data: NodeData = { nodeId };
                     try {
                         data.table = await controller.getMiscInfo(nodeId);
-                        data.live_isAlive = await controller.live_isAlive(nodeId);
-                        data.live_exposedControllers = await controller.getExposedControllers(nodeId);
-                        data.live_entryPoint = await controller.live_getEntryPoint(nodeId);
-                        data.live_trueTimeOffset = await controller.live_getTrueTimeOffset(nodeId);
+                        let metadata = await controller.live_getMetadata(nodeId);
+                        data.live_isAlive = !!metadata;
+                        data.live_exposedControllers = metadata?.exposedControllers;
+                        data.live_entryPoint = metadata?.entryPoint;
+                        data.live_trueTimeOffset = metadata?.trueTimeOffset;
                         data.live_authorityPaths = await controller.live_getAuthorityPaths(nodeId);
                         data.ip = await controller.getNodeIP(nodeId);
                         if (data.ip === ourExternalIP || data.ip === ourIP) {
@@ -484,27 +485,18 @@ class NodeViewerControllerBase {
         await syncNodesNow();
     }
 
-    public async getExposedControllers(nodeId: string) {
-        return await NodeCapabilitiesController.nodes[nodeId].getExposedControllers();
+    public async live_getMetadata(nodeId: string) {
+        return await errorToUndefinedSilent(NodeCapabilitiesController.nodes[nodeId].getMetadata());
     }
 
     public async getControllerNodeIdList(controller: SocketRegistered<{}>) {
         return await getControllerNodeIdList(controller);
     }
 
-    public async live_isAlive(nodeId: string) {
-        return !!await errorToUndefinedSilent(NodeCapabilitiesController.nodes[nodeId].getEntryPoint());
-    }
     public async live_getAuthorityPaths(nodeId: string) {
         let topo = await NodeMetadataController.nodes[nodeId].debugGetTopologyEntry(nodeId);
         return topo?.authoritySpec;
     }
-    public async live_getEntryPoint(nodeId: string) {
-        return NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
-    }
-    public async live_getTrueTimeOffset(nodeId: string) {
-        return NodeCapabilitiesController.nodes[nodeId].getTrueTimeOffset();
-    }
 
     public async getMiscInfo(nodeId: string): Promise<{
         columns: ColumnsType;
@@ -521,18 +513,19 @@ class NodeViewerControllerBase {
                 row[columnName] = "Error: " + e.stack;
             }
         }
+        let metadataPromise = NodeCapabilitiesController.nodes[nodeId].getMetadata();
         let promises = [
             wrapAddTableValue("paths|paths", {}, async () => {
                 let live_authorityPaths = (await NodeMetadataController.nodes[nodeId].debugGetPathAuthorities(nodeId));
                 return JSON.stringify(live_authorityPaths);
             }),
             wrapAddTableValue("paths|functions", {}, async () => {
-                let live_functionRunnerShards = await NodeCapabilitiesController.nodes[nodeId].getFunctionRunnerShards();
-                return live_functionRunnerShards.map(x => `${x.domainName}[${x.shardRange.startFraction}-${x.shardRange.endFraction}]${x.secondaryShardRange && `+[${x.secondaryShardRange?.startFraction || 0}-${x.secondaryShardRange?.endFraction || 0}]` || ""}`).join(" | ");
+                let metadata = await metadataPromise;
+                return metadata.functionRunnerShards.map(x => `${x.domainName}[${x.shardRange.startFraction}-${x.shardRange.endFraction}]${x.secondaryShardRange && `+[${x.secondaryShardRange?.startFraction || 0}-${x.secondaryShardRange?.endFraction || 0}]` || ""}`).join(" | ");
             }),
             wrapAddTableValue("uptime", { formatter: "timeSpan" }, async () => {
-                let startupTime = await NodeCapabilitiesController.nodes[nodeId].getStartupTime();
-                return Date.now() - startupTime;
+                let metadata = await metadataPromise;
+                return Date.now() - metadata.startupTime;
             }),
             wrapAddTableValue("port", {}, async () => {
                 return nodeId.split(":").at(-1);
@@ -557,8 +550,8 @@ class NodeViewerControllerBase {
                 ].filter(x => x);
             }),
             wrapAddTableValue("capabilities|capabilities", {}, async () => {
-                let live_exposedControllers = await NodeCapabilitiesController.nodes[nodeId].getExposedControllers();
-                return live_exposedControllers.map(x => x.split("-")[0]);
+                let metadata = await metadataPromise;
+                return metadata.exposedControllers.map(x => x.split("-")[0]);
             }),
         ];
         await Promise.allSettled(promises);
@@ -590,12 +583,9 @@ export const NodeViewerController = SocketFunction.register(
         getExternalInspectURL: {},
         verifyAccess: {},
         getAllNodeIds: {},
-        getExposedControllers: {},
         getControllerNodeIdList: {},
-        live_isAlive: {},
+        live_getMetadata: {},
         live_getAuthorityPaths: {},
-        live_getEntryPoint: {},
-        live_getTrueTimeOffset: {},
         getMiscInfo: {},
 
         forceRefreshNodes: {},

package/src/diagnostics/debugger/mcp-server.ts

@@ -168,17 +168,17 @@ async function getNodeInfos(): Promise<NodeInfo[]> {
     const nodes = await getAllNodeIds();
     return Promise.all(
         nodes.map(async (nodeId): Promise<NodeInfo> => {
-            const [entryPoint, inspectUrl] = await Promise.all([
+            const [metadata, inspectUrl] = await Promise.all([
                 timeoutToUndefinedSilent(
                     NODE_INFO_TIMEOUT_MS,
-                    NodeCapabilitiesController.nodes[nodeId].getEntryPoint(),
+                    NodeCapabilitiesController.nodes[nodeId].getMetadata(),
                 ),
                 timeoutToUndefinedSilent(
                     NODE_INFO_TIMEOUT_MS,
                     NodeCapabilitiesController.nodes[nodeId].getInspectURL(),
                 ),
             ]);
-            return { nodeId, entryPoint, inspectUrl };
+            return { nodeId, entryPoint: metadata?.entryPoint, inspectUrl };
         }),
     );
 }

package/src/diagnostics/logs/IndexedLogs/IndexedLogs.ts

@@ -290,8 +290,8 @@ export class IndexedLogs<T> {
                 if (!hasLogger) return false;
                 // NOTE: Prefer to do the searching on the move logs service. However, if it's not available, any service can do searching. It just might lag that server... 
                 if (preferredOnly) {
-                    let entryPoint = await timeoutToUndefinedSilent(2500, NodeCapabilitiesController.nodes[nodeId].getEntryPoint());
-                    if (!entryPoint?.includes("movelogs")) return false;
+                    let metadata = await timeoutToUndefinedSilent(2500, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+                    if (!metadata?.entryPoint.includes("movelogs")) return false;
                 }
                 added = true;