querysub 0.450.0 → 0.452.0

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;
 

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

@@ -27,6 +27,32 @@ const PROGRESS_LOG_INTERVAL = timeInSecond * 5;
 const LOGGER_NAMES = ["logs/log", "logs/info", "logs/warn", "logs/error"] as const;
 type LoggerName = typeof LOGGER_NAMES[number];
 
+// Public-facing short names callers pass in via the `logTypes` parameter, mapped
+//  to the internal logger names above.
+const EXTERNAL_TO_INTERNAL_LOGGER: Record<string, LoggerName> = {
+    "log": "logs/log",
+    "info": "logs/info",
+    "warn": "logs/warn",
+    "error": "logs/error",
+};
+
+// Parses the caller's `logTypes` string (e.g. "warn|error") into the matching
+//  internal logger names. Empty / undefined means "all four" (no restriction).
+function parseLogTypes(value: string | undefined): readonly LoggerName[] {
+    if (!value) return LOGGER_NAMES;
+    let parts = value.split("|").map(s => s.trim().toLowerCase()).filter(s => s);
+    if (parts.length === 0) return LOGGER_NAMES;
+    let result: LoggerName[] = [];
+    for (let p of parts) {
+        let internal = EXTERNAL_TO_INTERNAL_LOGGER[p];
+        if (!internal) {
+            throw new Error(`logTypes: unknown log type ${JSON.stringify(p)}; expected one of log, info, warn, error (separated by "|")`);
+        }
+        if (!result.includes(internal)) result.push(internal);
+    }
+    return result;
+}
+
 // Per-logger accounting for one search. Byte counts are raw buffer sizes.
 export type LoggerStats = {
     // Files in range matching the requested machine.
@@ -142,8 +168,11 @@ function createProgressLogger(): (message: string) => void {
 }
 
 export class MCPIndexedLogs {
-    // machineId -> latest timestamp guaranteed to already be moved-to-public.
-    private movedThroughByMachine = new Map<string, number>();
+    // `${machineId}|${loggerName}` -> latest timestamp guaranteed to already be
+    //  moved-to-public for that specific (machine, logger). Keyed per-logger so
+    //  a search scoped to only some loggers doesn't poison the cache for the
+    //  others.
+    private movedThroughByMachineLogger = new Map<string, number>();
 
     // Cache: `${type}|${loggerName}|${startBucket}|${endBucket}` -> { time, paths }.
     // Buckets are hour-aligned start/end so adjacent searches reuse work.
@@ -157,11 +186,15 @@ export class MCPIndexedLogs {
         direction: Direction;
         columns: string[];
         limit?: number;
+        // Optional pipe-separated list restricting which log streams to scan
+        //  (e.g. "warn|error", "log"). Omit / empty = all four streams.
+        logTypes?: string;
     }): Promise<SearchResult> {
         let limit = config.limit ?? 100;
         let startTime = normalizeTime(config.startTime, "startTime");
         let endTime = normalizeTime(config.endTime, "endTime");
-        console.log(`[search] query=${JSON.stringify(config.query)} | machine=${config.machine} | startTime=${formatDateTime(startTime)} | endTime=${formatDateTime(endTime)} | direction=${config.direction} | columns=[${config.columns.join(",")}] | limit=${config.limit ?? "(default)"}`);
+        let enabledLoggers = parseLogTypes(config.logTypes);
+        console.log(`[search] query=${JSON.stringify(config.query)} | machine=${config.machine} | startTime=${formatDateTime(startTime)} | endTime=${formatDateTime(endTime)} | direction=${config.direction} | columns=[${config.columns.join(",")}] | limit=${config.limit ?? "(default)"} | logTypes=${config.logTypes ?? "(all)"}`);
         let now = Date.now();
         if (endTime > now - END_TIME_MIN_AGE) {
             throw new Error(`endTime must be at least ${formatTime(END_TIME_MIN_AGE)} in the past (got ${formatTime(now - endTime)} ago)`);
@@ -173,7 +206,7 @@ export class MCPIndexedLogs {
         let machineId = config.machine === "local" ? getOwnMachineId() : config.machine;
 
         let moveStart = Date.now();
-        let moveOutcome = await this.ensureMovedThrough(machineId, endTime);
+        let moveOutcome = await this.ensureMovedThrough(machineId, endTime, enabledLoggers);
         console.log(`[search] ensureMovedThrough ${moveOutcome} in ${formatTime(Date.now() - moveStart)}`);
 
         let loggers = await getLoggers2Async();
@@ -190,7 +223,7 @@ export class MCPIndexedLogs {
 
         let pathsStart = Date.now();
         let totalPathsSeen = 0;
-        await Promise.all(LOGGER_NAMES.map(async (loggerName) => {
+        await Promise.all(enabledLoggers.map(async (loggerName) => {
             let logger = this.getLoggerByName(loggers, loggerName);
             let archives = logger.debugGetCachedLogs({ type: useType });
 
@@ -300,9 +333,11 @@ export class MCPIndexedLogs {
 
         // Trim the internal LoggerStats down to just total + scanned. The rest
         // (bytes/blocks/timing) stays in the console.log above and is NOT
-        // returned — see the warning on SearchResult.
+        // returned — see the warning on SearchResult. We only emit entries for
+        // the loggers we actually searched, so a caller who scoped to
+        // `warn|error` doesn't see misleading 0s for the loggers they skipped.
         let files: Record<string, { total: number; scanned: number }> = {};
-        for (let name of LOGGER_NAMES) {
+        for (let name of enabledLoggers) {
             files[name] = { total: fileCounts[name].total, scanned: fileCounts[name].scanned };
         }
 
@@ -450,16 +485,20 @@ export class MCPIndexedLogs {
         sink.loggerStats.rows++;
     }
 
-    // For each logger, asks each remote node on the target machine whether it
-    // has pending logs overlapping [0, endTime]. The first node that answers
-    // without throwing wins; if it says yes, we ask the same node to flush.
-    // We iterate because not every node necessarily exposes the new endpoints
-    // (e.g. older versions still running). Records moved-through up to
-    // now - MOVE_GRACE so we skip this on subsequent calls covering the same
-    // window.
-    private async ensureMovedThrough(machineId: string, endTime: number): Promise<"cached" | "no-node" | "moved"> {
-        let lastMoved = this.movedThroughByMachine.get(machineId) ?? 0;
-        if (lastMoved >= endTime) return "cached";
+    // For each requested logger, asks each remote node on the target machine
+    // whether it has pending logs overlapping [0, endTime]. The first node that
+    // answers without throwing wins; if it says yes, we ask the same node to
+    // flush. We iterate because not every node necessarily exposes the new
+    // endpoints (e.g. older versions still running). Records moved-through up
+    // to now - MOVE_GRACE per (machine, logger) so we skip this on subsequent
+    // calls covering the same window. Only the loggers listed in `loggers` are
+    // touched; the others aren't queried or flushed.
+    private async ensureMovedThrough(machineId: string, endTime: number, loggers: readonly LoggerName[]): Promise<"cached" | "no-node" | "moved"> {
+        let needed = loggers.filter(name => {
+            let lastMoved = this.movedThroughByMachineLogger.get(`${machineId}|${name}`) ?? 0;
+            return lastMoved < endTime;
+        });
+        if (needed.length === 0) return "cached";
 
         let nodeIds = await this.findRemoteNodesOnMachine(machineId);
         if (nodeIds.length === 0) {
@@ -467,7 +506,7 @@ export class MCPIndexedLogs {
             return "no-node";
         }
 
-        for (let loggerName of LOGGER_NAMES) {
+        for (let loggerName of needed) {
             let answered = false;
             for (let nodeId of nodeIds) {
                 try {
@@ -495,7 +534,10 @@ export class MCPIndexedLogs {
             }
         }
 
-        this.movedThroughByMachine.set(machineId, Date.now() - MOVE_GRACE);
+        let recordTime = Date.now() - MOVE_GRACE;
+        for (let loggerName of needed) {
+            this.movedThroughByMachineLogger.set(`${machineId}|${loggerName}`, recordTime);
+        }
         return "moved";
     }
 
@@ -511,11 +553,11 @@ export class MCPIndexedLogs {
         let preferred: string[] = [];
         let rest: string[] = [];
         await Promise.all(candidates.map(async (nodeId) => {
-            let entry = await timeoutToUndefinedSilent(
+            let metadata = await timeoutToUndefinedSilent(
                 2500,
-                NodeCapabilitiesController.nodes[nodeId].getEntryPoint(),
+                NodeCapabilitiesController.nodes[nodeId].getMetadata(),
             );
-            if (entry?.includes("movelogs")) preferred.push(nodeId);
+            if (metadata?.entryPoint.includes("movelogs")) preferred.push(nodeId);
             else rest.push(nodeId);
         }));
         return [...preferred, ...rest];

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

@@ -14,12 +14,15 @@ module.hotreload = false;
 import "../../../inject";
 
 import * as http from "http";
-import { logErrors } from "../../../errors";
+import { logErrors, timeoutToUndefinedSilent } from "../../../errors";
 import { Querysub } from "../../../4-querysub/QuerysubController";
 import { MCPIndexedLogs } from "./MCPIndexedLogs";
+import { getAllNodeIds } from "../../../-f-node-discovery/NodeDiscovery";
+import { NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
 import { formatTime } from "socket-function/src/formatting/format";
 
 const DEFAULT_MCP_HTTP_PORT = 4487;
+const NODE_INFO_TIMEOUT_MS = 5000;
 
 const PROTOCOL_VERSION = "2025-03-26";
 const SERVER_INFO = { name: "querysub-indexed-logs", version: "0.1.0" };
@@ -33,6 +36,8 @@ Returns { allColumns, results, files: { <loggerName>: {total, scanned} } }. If a
 
 \`allColumns\` is the union of every key seen on any returned row, so callers can pick additional columns for follow-up calls.
 
+Optional \`logTypes\` parameter restricts which log streams are scanned. Pass a pipe-separated list of \`log\`, \`info\`, \`warn\`, \`error\` (e.g. \`"warn|error"\`, \`"log"\`). Omit to search all four. The returned \`files\` object only includes the streams you asked for.
+
 Query syntax (case-insensitive substring match by default):
   | — OR. \`cat|dog\` matches if either substring is present.
   & — AND. \`error&timeout\` matches if both are present (in any order, anywhere).
@@ -50,10 +55,19 @@ Note: each segment between operators ideally has at least 4 contiguous character
                 direction: { type: "string", enum: ["fromStart", "fromEnd"] },
                 columns: { type: "array", items: { type: "string" }, description: "Which fields to project onto each row. Use [] to get just metadata; use allColumns from a prior result to pick more." },
                 limit: { type: "number", default: 100 },
+                logTypes: { type: "string", description: "Optional pipe-separated list restricting which log streams to scan. Allowed values: log, info, warn, error. Examples: \"warn|error\", \"log\". Omit (default) to search all four." },
             },
             required: ["query", "machine", "startTime", "endTime", "direction", "columns"],
         },
     },
+    {
+        name: "listNodes",
+        description: `List every node in the Querysub cluster, with each node's process entry point. Returns an array of { nodeId, entryPoint }. A node that does not answer in time has entryPoint left undefined.`,
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
 ];
 
 type JsonRpcRequest = {
@@ -122,6 +136,8 @@ async function dispatch(method: string, params: unknown, mcp: MCPIndexedLogs): P
         let result: unknown;
         if (toolName === "search") {
             result = await mcp.search(args as Parameters<MCPIndexedLogs["search"]>[0]);
+        } else if (toolName === "listNodes") {
+            result = await getNodeInfos();
         } else {
             throw new Error(`Unknown tool ${toolName}`);
         }
@@ -143,6 +159,21 @@ function errorResponse(id: number | string | null, code: number, message: string
     return { jsonrpc: "2.0", id, error: { code, message } };
 }
 
+type NodeInfo = {
+    nodeId: string;
+    entryPoint?: string;
+};
+
+async function getNodeInfos(): Promise<NodeInfo[]> {
+    let nodes = await getAllNodeIds();
+    return Promise.all(
+        nodes.map(async (nodeId): Promise<NodeInfo> => {
+            let metadata = await timeoutToUndefinedSilent(NODE_INFO_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint };
+        }),
+    );
+}
+
 async function main() {
     let mcp = new MCPIndexedLogs();
 

package/src/diagnostics/managementPages.tsx

@@ -40,6 +40,7 @@ let pages: {
     componentName: string;
     title: string;
 }[] = [];
+let headerNotifications: preact.ComponentClass[] = [];
 
 let __schema: SchemaObject<unknown, {
     isManagementUser: () => boolean;
@@ -63,6 +64,9 @@ export async function registerManagementPages2(config: {
         controllerName?: string;
         getModule: () => Promise<any>;
 
+        // If provided, this component (exported from getModule) is rendered in the management header.
+        notificationComponentName?: string;
+
         title?: string;
     }[];
 }) {
@@ -89,6 +93,12 @@ export async function registerManagementPages2(config: {
         controllerName: "NodeViewerController",
         getModule: () => import("./NodeViewer"),
     });
+    inputPages.push({
+        title: "Authority Specs",
+        componentName: "AuthoritySpecPage",
+        controllerName: "AuthoritySpecPageController",
+        getModule: () => import("./misc-pages/AuthoritySpecPage"),
+    });
     inputPages.push({
         title: "LOG VIEWER",
         componentName: "LogViewer3",
@@ -240,6 +250,9 @@ export async function registerManagementPages2(config: {
                 componentName: page.componentName,
                 componentClass: createLazyComponent(page.getModule)(page.componentName),
             });
+            if (page.notificationComponentName) {
+                headerNotifications.push(createLazyComponent(page.getModule)(page.notificationComponentName));
+            }
         }
     }
 }
@@ -299,6 +312,7 @@ export function renderIsManagementUser() {
 }
 
 const ErrorWarning = createLazyComponent(() => import("./logs/errorNotifications2/ErrorWarning"))("ErrorWarning");
+const LaunchTrackingHeader = createLazyComponent(() => import("../deployManager/LaunchTrackingHeader"))("LaunchTrackingHeader");
 
 class ManagementRoot extends qreact.Component {
     state = {
@@ -355,6 +369,7 @@ class ManagementRoot extends qreact.Component {
                     </style>
                     <div class={css.fillWidth.hbox(20, 4).wrap.hsl(245, 25, 80).pad2(20, 4).pointerEvents("all")}>
                         <ErrorWarning />
+                        {headerNotifications.map(N => <N />)}
                         <ATag values={[
                             managementPageURL.getOverride("MachinesPage"),
                             currentViewParam.getOverride("services"),
@@ -370,6 +385,7 @@ class ManagementRoot extends qreact.Component {
                         {isCurrentUserSuperUser() && <div className={css.vbox(4)}>
                             <PathDistributionInfo />
                             <ValuePathWarning />
+                            <LaunchTrackingHeader />
                         </div>}
                     </div>
                     {currentPage &&

package/src/diagnostics/misc-pages/AuthoritySpecPage.tsx

@@ -0,0 +1,112 @@
+module.allowclient = true;
+
+import { qreact } from "../../4-dom/qreact";
+import { css } from "typesafecss";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getAllNodeIds, getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
+import { getSyncedController } from "../../library-components/SyncedController";
+import { assertIsManagementUser } from "../managementPages";
+import { NodeCapabilitiesController } from "../../-g-core-values/NodeCapabilities";
+import { timeoutToUndefinedSilent } from "../../errors";
+import { sort } from "socket-function/src/misc";
+import type { AuthoritySpec } from "../../0-path-value-core/PathRouter";
+
+const PROBE_TIMEOUT_MS = 5000;
+const RANGE_BAR_WIDTH_PX = 360;
+const RANGE_BAR_HEIGHT_PX = 14;
+
+type NodeAuthorityInfo = {
+    nodeId: string;
+    entryPoint?: string;
+    spec?: AuthoritySpec;
+};
+
+class AuthoritySpecPageControllerBase {
+    public async getAllNodeAuthoritySpecs(): Promise<NodeAuthorityInfo[]> {
+        let nodes = await getAllNodeIds();
+        return Promise.all(nodes.map(async (nodeId): Promise<NodeAuthorityInfo> => {
+            let metadata = await timeoutToUndefinedSilent(PROBE_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint, spec: metadata?.authoritySpec };
+        }));
+    }
+}
+
+export const AuthoritySpecPageController = SocketFunction.register(
+    "AuthoritySpecPageController-7b8c9d0e-1f2a-3b4c-5d6e-7f8090a1b2c3",
+    new AuthoritySpecPageControllerBase(),
+    () => ({
+        getAllNodeAuthoritySpecs: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);
+
+const AuthoritySpecSynced = getSyncedController(AuthoritySpecPageController, {
+    reads: { getAllNodeAuthoritySpecs: ["nodeAuthoritySpecs"] },
+    writes: {},
+});
+
+class AuthorityRangeBar extends qreact.Component<{ start: number; end: number }> {
+    render() {
+        let startPct = this.props.start * 100;
+        let widthPct = (this.props.end - this.props.start) * 100;
+        return <div className={css.relative.size(RANGE_BAR_WIDTH_PX, RANGE_BAR_HEIGHT_PX).flexShrink0.hsl(0, 0, 92).bord2(0, 0, 75)}>
+            <div className={css.absolute.top(0).left(`${startPct}%`).size(`${widthPct}%`, "100%").hsl(210, 65, 50)} />
+        </div>;
+    }
+}
+
+class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo }> {
+    render() {
+        let info = this.props.info;
+        let spec = info.spec;
+        return <div className={css.vbox(6).pad2(10).fillWidth.bord2(0, 0, 85).hsl(0, 0, 99)}>
+            <div className={css.hbox(10).fillWidth}>
+                <span className={css.boldStyle}>{info.nodeId}</span>
+                <span className={css.colorhsl(0, 0, 40).ellipsis.flexFillWidth}>{info.entryPoint || "(no entry point)"}</span>
+            </div>
+            {!spec &&
+                <div className={css.colorhsl(0, 60, 35)}>(no authority spec returned)</div>
+            }
+            {spec &&
+                <div className={css.vbox(6).fillWidth}>
+                    <div className={css.hbox(10)}>
+                        <span>{spec.routeStart.toFixed(4)} - {spec.routeEnd.toFixed(4)}</span>
+                        <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />
+                        <span className={css.colorhsl(0, 0, 50)}>width {(spec.routeEnd - spec.routeStart).toFixed(4)}</span>
+                        {spec.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
+                    </div>
+                    <div className={css.vbox(2)}>
+                        <div className={css.boldStyle}>Prefixes ({spec.prefixes.length}):</div>
+                        {spec.prefixes.length === 0 && <div className={css.colorhsl(0, 0, 50)}>(none)</div>}
+                        {spec.prefixes.map(p =>
+                            <div key={p.originalPrefix} className={css.colorhsl(0, 0, 25)}>{p.originalPrefix}</div>
+                        )}
+                    </div>
+                </div>
+            }
+        </div>;
+    }
+}
+
+export class AuthoritySpecPage extends qreact.Component {
+    render() {
+        let infos = AuthoritySpecSynced(getBrowserUrlNode()).getAllNodeAuthoritySpecs();
+        if (!infos) {
+            return <div className={css.pad2(16)}>Loading authority specs...</div>;
+        }
+        let sorted = [...infos];
+        sort(sorted, x => x.spec ? x.spec.routeStart : 2);
+
+        return <div className={css.vbox(12).pad2(16).fillWidth}>
+            <h2>Node Authority Specs ({infos.length})</h2>
+            <div className={css.vbox(8).fillWidth}>
+                {sorted.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
+            </div>
+        </div>;
+    }
+}

package/src/diagnostics/pathAuditer.ts

@@ -333,8 +333,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         if (response.valid && response.time && compareTime(response.time, ourValue.time) > 0) {
             valuesToRequest.push({ path: response.path, time: response.time });
             let authorities = PathRouter.getAllAuthorities(response.path);
-            debugbreak(2);
-            debugger;
             trackSyncAge({
                 path: response.path,
                 ourTimeId: ourValue.time.time,
@@ -349,8 +347,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         //      - Send it our value
         else if (response.valid === undefined && (!response.time || compareTime(ourValue.time, response.time) > 0)) {
             valuesToSend.push(ourValue);
-            debugbreak(2);
-            debugger;
             trackSyncAge({
                 path: response.path,
                 ourTimeId: ourValue.time.time,
@@ -370,8 +366,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
             let age = now - ourValue.time.time;
             if (age >= MAX_CHANGE_AGE) {
                 pathsToForceSync.add(response.path);
-                debugbreak(2);
-                debugger;
                 trackSyncAge({
                     path: response.path,
                     ourTimeId: ourValue.time.time,

package/test.ts

@@ -43,7 +43,8 @@ async function main() {
 
     let nodes = await getAllNodeIds();
     let values = await Promise.all(nodes.map(async node => {
-        return timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getEntryPoint());
+        let metadata = await timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getMetadata());
+        return metadata?.entryPoint;
     }));
     console.log({ values });
 

package/src/misc/getParentProcessId.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Text;
-using System.Runtime.InteropServices;
-
-public class PPIDService
-{
-    [DllImport("kernel32.dll")]
-    static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
-
-    [DllImport("kernel32.dll")]
-    static extern bool CloseHandle(IntPtr hObject);
-
-    [DllImport("ntdll.dll")]
-    static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref PROCESS_BASIC_INFORMATION pbi, int processInformationLength, out int returnLength);
-
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct PROCESS_BASIC_INFORMATION
-    {
-        public IntPtr Reserved1;
-        public IntPtr PebBaseAddress;
-        public IntPtr Reserved2_0;
-        public IntPtr Reserved2_1;
-        public IntPtr UniqueProcessId;
-        public IntPtr InheritedFromUniqueProcessId;
-    }
-
-    public static int GetParentProcessId(int pid)
-    {
-        IntPtr hProcess = OpenProcess(0x1000, false, pid);
-        if (hProcess == IntPtr.Zero)
-        {
-            return 0;
-        }
-
-        try
-        {
-            PROCESS_BASIC_INFORMATION pbi = new PROCESS_BASIC_INFORMATION();
-            int returnLength;
-            int status = NtQueryInformationProcess(hProcess, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength);
-            if (status == 0)
-            {
-                return pbi.InheritedFromUniqueProcessId.ToInt32();
-            }
-        }
-        finally
-        {
-            CloseHandle(hProcess);
-        }
-
-        return 0;
-    }
-}