querysub 0.403.0 → 0.404.0

package/src/diagnostics/NodeViewer.tsx

@@ -1,43 +1,34 @@
-import preact from "preact"; import { qreact } from "../../src/4-dom/qreact";
+import { qreact } from "../../src/4-dom/qreact";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { css } from "typesafecss";
-import { getAllNodeIds, getBrowserUrlNode, getOwnNodeId, syncNodesNow } from "../../src/-f-node-discovery/NodeDiscovery";
+import { getAllNodeIds, getBrowserUrlNode, syncNodesNow } from "../../src/-f-node-discovery/NodeDiscovery";
 import { errorToUndefined, logErrors, timeoutToError } from "../../src/errors";
-import { Querysub } from "../../src/4-querysub/QuerysubController";
+import { Querysub, QuerysubController } from "../../src/4-querysub/QuerysubController";
 import { NodeCapabilitiesController, getControllerNodeIdList } from "../../src/-g-core-values/NodeCapabilities";
-import { AuthorityPath, debug_getAuthorityPaths, debug_isReadReady, nodePathAuthority } from "../../src/0-path-value-core/NodePathAuthorities";
 import { lazy } from "socket-function/src/caching";
 import { atomicObjectWrite } from "../../src/2-proxy/PathValueProxyWatcher";
-import { formatNumber } from "socket-function/src/formatting/format";
 import { Button } from "../../src/library-components/Button";
 import { URLParam } from "../../src/library-components/URLParam";
 import { InputLabelURL } from "../../src/library-components/InputLabel";
 import { ColumnType, ColumnsType, RowType, Table, TableType } from "../../src/5-diagnostics/Table";
-import { MaybePromise } from "socket-function/src/types";
-import { requiresNetworkTrustHook } from "../../src/-d-trust/NetworkTrust2";
-import { getDomain, isNoNetwork } from "../../src/config";
+import { getDomain } from "../../src/config";
 import { NodeMetadataController } from "../../src/5-diagnostics/nodeMetadata";
-import { isDefined } from "../../src/misc";
-import { encodeFormattedSelector, errorMessage, formatValue, toSpaceCase } from "../../src/5-diagnostics/GenericFormat";
-import { ValueAuditController } from "../../src/5-diagnostics/memoryValueAudit";
+import { errorMessage, formatValue, toSpaceCase } from "../../src/5-diagnostics/GenericFormat";
 import { getExternalIP } from "../../src/misc/networking";
 import dns from "dns";
-import { getNodeIdDomain, getNodeIdDomainMaybeUndefined, getNodeIdIP } from "socket-function/src/nodeCache";
-import ws from "ws";
-import https from "https";
-import debugbreak from "debugbreak";
+import { getNodeIdDomainMaybeUndefined, getNodeIdIP } from "socket-function/src/nodeCache";
 import { forwardPort } from "socket-function/src/forwardPort";
 import { setRecord } from "../-b-authorities/dnsAuthority";
-import tls from "tls";
-import net from "net";
 import { ButtonSelector } from "../library-components/ButtonSelector";
-import { assertIsManagementUser, managementPageURL } from "./managementPages";
+import { assertIsManagementUser } from "./managementPages";
 import { SocketRegistered } from "socket-function/SocketFunctionTypes";
 import { ATag } from "../library-components/ATag";
 import { getSyncedController } from "../library-components/SyncedController";
 import child_process from "child_process";
 import { getHTTPSKeyCert } from "../-e-certs/certAuthority";
 import { getLogViewerParams } from "./logs/IndexedLogs/LogViewerParams";
+import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
+import { AuthoritySpec } from "../0-path-value-core/PathRouter";
 
 
 type NodeData = {
@@ -46,10 +37,11 @@ type NodeData = {
     ip?: string;
     devToolsURL?: string;
 
-    live_isReadReady?: number;
-    live_authorityPaths?: AuthorityPath[];
+    live_isReadReady?: boolean;
+    live_authorityPaths?: AuthoritySpec;
     live_exposedControllers?: string[];
     live_entryPoint?: string;
+    live_trueTimeOffset?: number;
     apiError?: string;
     table?: {
         columns: ColumnsType;
@@ -86,16 +78,11 @@ export class NodeViewer extends qreact.Component {
                     let time = Date.now();
                     let data: NodeData = { nodeId };
                     try {
-                        if (nodeId.includes("b3a757")) {
-                            debugger;
-                        }
                         data.table = await controller.getMiscInfo(nodeId);
-                        if (nodeId.includes("b3a757")) {
-                            debugger;
-                        }
                         data.live_isReadReady = await controller.live_isReadReady(nodeId);
                         data.live_exposedControllers = await controller.getExposedControllers(nodeId);
                         data.live_entryPoint = await controller.live_getEntryPoint(nodeId);
+                        data.live_trueTimeOffset = await controller.live_getTrueTimeOffset(nodeId);
                         data.live_authorityPaths = await controller.live_getAuthorityPaths(nodeId);
                         data.ip = await controller.getNodeIP(nodeId);
                         if (data.ip === ourExternalIP || data.ip === ourIP) {
@@ -110,6 +97,7 @@ export class NodeViewer extends qreact.Component {
                             debugger;
                         }
                     } catch (e: any) {
+                        if (e.stack.includes("Tried to call a different thread")) return;
                         data.apiError = "Error: " + e.stack;
                         if (nodeId.includes("b3a757")) {
                             debugger;
@@ -187,7 +175,7 @@ export class NodeViewer extends qreact.Component {
         tables["PathValueServer"] = [];
         tables["Querysub"] = [];
         for (let datum of nodeDatas) {
-            if (datum.live_authorityPaths?.length) {
+            if (datum.live_authorityPaths) {
                 tables["PathValueServer"].push(datum);
             } else if (datum.live_exposedControllers?.includes("QuerysubController-6db5ef05-7563-4473-a440-2f64f03fe6ef")) {
                 tables["Querysub"].push(datum);
@@ -199,7 +187,7 @@ export class NodeViewer extends qreact.Component {
         }
 
         let builtinGroups = {
-            "Default": ["buttons", "devToolsURL", "nodeId", "ip", "uptime", "loadTime", "% Profiled", "All Memory", "port", "threadId", "machineId", "apiError", "live_entryPoint"],
+            "Default": ["buttons", "devToolsURL", "nodeId", "ip", "uptime", "loadTime", "% Profiled", "All Memory", "port", "threadId", "machineId", "apiError", "live_entryPoint", "live_trueTimeOffset"],
             "Performance": [
                 "All Memory",
                 "Heap", "Buffers",
@@ -266,8 +254,7 @@ export class NodeViewer extends qreact.Component {
                                 buttons: {
                                     formatter: () => {
                                         return <span class={css.hbox(6)}>
-                                            <Button onClick={() => NodeViewerController.nodes[getBrowserUrlNode()].diskAuditNow(x.nodeId)}>Disk Audit</Button>
-                                            <Button onClick={() => NodeViewerController.nodes[getBrowserUrlNode()].memoryAuditNow(x.nodeId)}>Memory Audit</Button>
+
                                         </span>;
                                     }
                                 },
@@ -306,6 +293,9 @@ export class NodeViewer extends qreact.Component {
                                 },
                                 ip: {},
                                 loadTime: { title: "Meta Time", formatter: "timeSpan" },
+                                live_trueTimeOffset: {
+                                    title: "Time Offset", formatter: x => String(x)
+                                },
                                 ...x.table?.columns,
                                 //capabilities: null,
                                 apiError: { formatter: "error" },
@@ -503,14 +493,19 @@ class NodeViewerControllerBase {
     }
 
     public async live_isReadReady(nodeId: string) {
-        return debug_isReadReady(nodeId);
+        let topo = await QuerysubController.nodes[nodeId].debugGetTopologyEntry(nodeId);
+        return !!topo?.isReady;
     }
     public async live_getAuthorityPaths(nodeId: string) {
-        return debug_getAuthorityPaths(nodeId);
+        let topo = await QuerysubController.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;
@@ -529,8 +524,8 @@ class NodeViewerControllerBase {
         }
         let promises = [
             wrapAddTableValue("paths|paths", {}, async () => {
-                let live_authorityPaths = await debug_getAuthorityPaths(nodeId);
-                return live_authorityPaths.map(x => JSON.stringify(x)).join(" | ");
+                let live_authorityPaths = (await QuerysubController.nodes[nodeId].debugGetPathAuthorities(nodeId));
+                return JSON.stringify(live_authorityPaths);
             }),
             wrapAddTableValue("paths|functions", {}, async () => {
                 let live_functionRunnerShards = await NodeCapabilitiesController.nodes[nodeId].getFunctionRunnerShards();
@@ -554,13 +549,15 @@ class NodeViewerControllerBase {
                 return nodeId.split(".").at(-3);
             }),
             wrapAddTableValue("miscAudits", { formatter: "varray:error" }, async () => {
-                let live_authorityPaths = await debug_getAuthorityPaths(nodeId);
-                let cached_authority = await nodePathAuthority.debug_getAuthority(nodeId);
-                let live_isReadReady = await debug_isReadReady(nodeId);
+                let liveTopo = await QuerysubController.nodes[nodeId].debugGetTopologyEntry(nodeId);
+                let live_authorityPaths = liveTopo?.authoritySpec;
+                let obj = await authorityLookup.getTopology();
+                let cached_authority = await obj.find(x => x.nodeId === nodeId);
+                let live_isReadReady = liveTopo?.isReady;
                 return [
                     live_isReadReady && !cached_authority && `Authority is missing in cache`,
-                    JSON.stringify(live_authorityPaths) !== JSON.stringify(cached_authority?.authorityPaths) && `Paths are out of sync. Cache has ${JSON.stringify(cached_authority?.authorityPaths)} live has ${JSON.stringify(live_authorityPaths)}`,
-                    live_isReadReady !== cached_authority?.isReadReady && `isReadReady is out of sync. Cache has ${cached_authority?.isReadReady} live has ${live_isReadReady}`,
+                    JSON.stringify(live_authorityPaths) !== JSON.stringify(cached_authority) && `Paths are out of sync. Cache has ${JSON.stringify(cached_authority)} live has ${JSON.stringify(live_authorityPaths)}`,
+                    live_isReadReady !== cached_authority?.isReady && `isReadReady is out of sync. Cache has ${cached_authority?.isReady} live has ${live_isReadReady}`,
                 ].filter(x => x);
             }),
             wrapAddTableValue("capabilities|capabilities", {}, async () => {
@@ -585,13 +582,6 @@ class NodeViewerControllerBase {
             row,
         };
     }
-
-    public async diskAuditNow(nodeId: string) {
-        await ValueAuditController.nodes[nodeId].diskAuditNow();
-    }
-    public async memoryAuditNow(nodeId: string) {
-        await ValueAuditController.nodes[nodeId].memoryAuditNow();
-    }
 }
 
 export const NodeViewerController = SocketFunction.register(
@@ -609,10 +599,9 @@ export const NodeViewerController = SocketFunction.register(
         live_isReadReady: {},
         live_getAuthorityPaths: {},
         live_getEntryPoint: {},
+        live_getTrueTimeOffset: {},
         getMiscInfo: {},
 
-        diskAuditNow: {},
-        memoryAuditNow: {},
         forceRefreshNodes: {},
     }),
     () => ({

package/src/diagnostics/SyncTestPage.tsx

@@ -0,0 +1,241 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../4-dom/qreact";
+import { assertIsManagementUser } from "./managementPages";
+import { getSyncedController } from "../library-components/SyncedController";
+import { Querysub } from "../4-querysub/QuerysubController";
+import { isRegisteredUserPERMISSIONS, isSuperUserPERMISSIONS } from "../user-implementation/userData";
+import { css } from "typesafecss";
+import { Button } from "../library-components/Button";
+import { InputLabel } from "../library-components/InputLabel";
+import { Input } from "../library-components/Input";
+import { authorityStorage } from "../0-path-value-core/pathValueCore";
+import { getAllNodeIds } from "../-f-node-discovery/NodeDiscovery";
+import { MachineThreadInfoController } from "./MachineThreadInfo";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { sort } from "socket-function/src/misc";
+import { PathAuditerController } from "./pathAuditer";
+import { t } from "../2-proxy/schema2";
+
+
+let { data, functions } = Querysub.createSchema<{
+    values: {
+        [key: string]: number;
+    };
+}>()({
+    functions: {
+        setValue(key: string, value: number) {
+            data().values[key] = value;
+        },
+        incrementValue(key: string) {
+            data().values[key]++;
+        },
+    },
+    module,
+    moduleId: "syncText",
+    functionMetadata: {
+        setValue: {
+            keyOverride: {
+                getPrefix: data => data().values,
+                getKey: (key: string, _value: number) => key,
+            },
+        },
+        incrementValue: {
+            keyOverride: {
+                getPrefix: data => data().values,
+                getKey: (key: string) => key,
+            },
+        },
+    },
+    permissions: {
+        PERMISSIONS: isSuperUserPERMISSIONS
+    }
+});
+
+
+function getUniqueThreadName(thread: { entrypoint: string; nodeId: string }, allThreads: { entrypoint: string; nodeId: string }[]): string {
+    function getDisplayName(entrypoint: string): string {
+        return entrypoint.replaceAll("\\", "/").split("/").slice(-3).join("/");
+    }
+    let baseName = getDisplayName(thread.entrypoint);
+    let duplicates = allThreads.filter(t => getDisplayName(t.entrypoint) === baseName);
+    if (duplicates.length > 1) {
+        let index = duplicates.findIndex(t => t.nodeId === thread.nodeId);
+        return `${baseName} [${index + 1}]`;
+    }
+    return baseName;
+}
+
+export class SyncTestPage extends qreact.Component {
+    state = t.state({
+        auditRunning: t.lookup({
+            isRunning: t.boolean
+        })
+    });
+
+    async runAudit(nodeId: string) {
+        this.state.auditRunning[nodeId] = { isRunning: true };
+        try {
+            await PathAuditerController.nodes[SocketFunction.browserNodeId()].runAuditNow_forBrowser(nodeId);
+        } finally {
+            Querysub.commit(() => {
+                this.state.auditRunning[nodeId] = { isRunning: false };
+            });
+        }
+    }
+
+    render() {
+        let values = data().values;
+        let allNodes = MachineThreadInfoController(SocketFunction.browserNodeId()).getAllInfo();
+        let allThreads = Array.from(allNodes?.byThread.values() || []);
+        allThreads = allThreads.slice();
+        sort(allThreads, x => x.entrypoint);
+
+        return (
+            <div className={css.pad2(20).vbox(40)}>
+                <h1>Sync Test Page</h1>
+
+                <div className={css.vbox(10)}>
+                    <div className={css.boldStyle}>Audit Controls</div>
+                    <div className={css.hbox(10, 5).wrap}>
+                        {allThreads.map(thread => {
+                            let auditStatus = this.state.auditRunning[thread.nodeId];
+                            let isRunning = auditStatus && "isRunning" in auditStatus && auditStatus.isRunning;
+                            return (
+                                <div className={css.hbox(5).hsl(0, 0, 95).pad2(5)} title={JSON.stringify(thread)}>
+                                    <div>{getUniqueThreadName(thread, allThreads)}</div>
+                                    <Button
+                                        onClick={() => this.runAudit(thread.nodeId)}
+                                        disabled={isRunning}
+                                    >
+                                        {isRunning && "Running..." || "Run Audit"}
+                                    </Button>
+                                </div>
+                            );
+                        })}
+                    </div>
+                </div>
+
+                <div className={css.vbox(20)}>
+                    {Object.entries(values).map(([key, value]) => {
+                        const valuePath = Querysub.getPath(() => data().values[key]);
+                        if (!valuePath) return undefined;
+                        const path = valuePath;
+                        return (
+                            <div className={css.vbox(0)}>
+                                <div className={css.hbox(10)}>
+                                    <span class={css.boldStyle}>{key}</span>
+                                    <span>{value}</span>
+                                    <Button onClick={() => functions.incrementValue(key)}>Increment</Button>
+                                    <InputLabel value={value} number onChangeValue={value => functions.setValue(key, +value)} />
+                                </div>
+                                <div className={css.hbox(10, 2).wrap.marginLeft(20)}>
+                                    {allThreads.map(thread => {
+                                        let result;
+                                        let hasError = false;
+                                        try {
+                                            result = syncTestController(SocketFunction.browserNodeId()).getValueAndTime_forBrowser({
+                                                path: path,
+                                                nodeId: thread.nodeId
+                                            });
+                                        } catch {
+                                            hasError = true;
+                                        }
+                                        if (hasError) return undefined;
+                                        return (
+                                            <div className={css.hbox(5).hsl(0, 0, 100).pad2(2)} title={JSON.stringify(thread)}>
+                                                <div>{getUniqueThreadName(thread, allThreads)}</div>
+                                                <Button onClick={async () => {
+                                                    await SyncTestController.nodes[SocketFunction.browserNodeId()].DEBUG_secretlyDeleteAllValuesWithPath_forBrowser({
+                                                        path: path,
+                                                        nodeId: thread.nodeId
+                                                    });
+                                                }}>
+                                                    Delete Value
+                                                </Button>
+                                                {hasError && <div>Error</div> || <>
+                                                    <div>Value: {result?.value}</div>
+                                                    <div>Time: {result?.time}</div>
+                                                </>}
+                                            </div>
+                                        );
+                                    })}
+                                </div>
+                            </div>
+                        );
+                    })}
+                </div>
+                <InputLabel
+                    label="Insert new key"
+                    onChangeValue={value => {
+                        functions.setValue(value, 0);
+                    }}
+                />
+                <Button onClick={() => {
+                    syncTestController.refreshAll();
+                }}>
+                    Refresh
+                </Button>
+            </div>
+        );
+    }
+}
+
+
+class SyncTestControllerBase {
+    async test() {
+        return Date.now();
+    }
+
+    public async DEBUG_secretlyDeleteAllValuesWithPath_forBrowser(config: {
+        path: string;
+        nodeId: string;
+    }) {
+        await SyncTestController.nodes[config.nodeId].DEBUG_secretlyDeleteAllValuesWithPath(config.path);
+    }
+
+    public async DEBUG_secretlyDeleteAllValuesWithPath(path: string) {
+        await authorityStorage.DEBUG_secretlyDeleteAllValuesWithPath(path);
+    }
+
+    public async getValueAndTime_forBrowser(config: {
+        path: string;
+        nodeId: string;
+    }) {
+        return await SyncTestController.nodes[config.nodeId].getValueAndTime(config.path);
+    }
+
+    public async getValueAndTime(path: string) {
+        let pathValue = authorityStorage.getValueAtTime(path);
+        let value = pathValueSerializer.getPathValue(pathValue);
+        let time = pathValue?.time.time;
+        return { value, time };
+    }
+}
+
+export const SyncTestController = SocketFunction.register(
+    "SyncTestController-019cc520-f449-710b-94df-80b7b3e0f787",
+    new SyncTestControllerBase(),
+    () => ({
+        test: {},
+        DEBUG_secretlyDeleteAllValuesWithPath_forBrowser: {},
+        DEBUG_secretlyDeleteAllValuesWithPath: {},
+        getValueAndTime_forBrowser: {},
+        getValueAndTime: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        // Auto expose, as we want our test functions to be exposed
+        //noAutoExpose: true,
+    }
+);
+
+let syncTestController = getSyncedController(SyncTestController, {
+    reads: {
+        getValueAndTime_forBrowser: ["value"],
+    },
+    writes: {
+        DEBUG_secretlyDeleteAllValuesWithPath_forBrowser: ["value"],
+    },
+});

package/src/diagnostics/auditImportViolations.ts

@@ -0,0 +1,185 @@
+import * as typescript from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+
+interface Violation {
+    importPath: string;
+    importStage: number;
+    fileStage: number;
+}
+
+interface FileViolations {
+    filePath: string;
+    fileStage: number;
+    violations: Violation[];
+}
+
+function getStageNumber(filePath: string): number | undefined {
+    let parts = filePath.split(/[\\/]/);
+    for (let part of parts) {
+        let match = part.match(/^(\d+)-/);
+        if (match) {
+            return parseInt(match[1]);
+        }
+    }
+    return undefined;
+}
+
+function getAllTypeScriptFiles(dir: string): string[] {
+    let results: string[] = [];
+    let entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (let entry of entries) {
+        let fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git") {
+                continue;
+            }
+            results.push(...getAllTypeScriptFiles(fullPath));
+        } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+            results.push(fullPath);
+        }
+    }
+
+    return results;
+}
+
+function resolveImportPath(importPath: string, fromFile: string, rootDir: string): string | undefined {
+    if (!importPath.startsWith(".")) {
+        return undefined;
+    }
+
+    let fromDir = path.dirname(fromFile);
+    let resolved = path.resolve(fromDir, importPath);
+
+    for (let ext of [".ts", ".tsx", ".js", ".jsx"]) {
+        if (fs.existsSync(resolved + ext)) {
+            return path.relative(rootDir, resolved + ext);
+        }
+    }
+
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+        for (let indexFile of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+            let indexPath = path.join(resolved, indexFile);
+            if (fs.existsSync(indexPath)) {
+                return path.relative(rootDir, indexPath);
+            }
+        }
+    }
+
+    return undefined;
+}
+
+function extractImports(filePath: string): string[] {
+    let content = fs.readFileSync(filePath, "utf-8");
+    let sourceFile = typescript.createSourceFile(
+        filePath,
+        content,
+        typescript.ScriptTarget.Latest,
+        true
+    );
+
+    let imports: string[] = [];
+
+    function visit(node: typescript.Node) {
+        if (typescript.isImportDeclaration(node)) {
+            let moduleSpecifier = node.moduleSpecifier;
+            if (typescript.isStringLiteral(moduleSpecifier)) {
+                imports.push(moduleSpecifier.text);
+            }
+        } else if (typescript.isExportDeclaration(node) && node.moduleSpecifier) {
+            if (typescript.isStringLiteral(node.moduleSpecifier)) {
+                imports.push(node.moduleSpecifier.text);
+            }
+        }
+        // NOTE: Dynamic imports (import("...")) are intentionally NOT included
+        // because they are lazy-loaded at runtime and should be allowed to
+        // import from higher stages
+
+        typescript.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+    return imports;
+}
+
+function checkFile(filePath: string, rootDir: string): FileViolations | undefined {
+    let fileStage = getStageNumber(filePath);
+    if (fileStage === undefined) {
+        return undefined;
+    }
+
+    let imports = extractImports(filePath);
+    let violations: Violation[] = [];
+
+    for (let importPath of imports) {
+        let resolvedPath = resolveImportPath(importPath, filePath, rootDir);
+        if (!resolvedPath) {
+            continue;
+        }
+
+        let importStage = getStageNumber(resolvedPath);
+        if (importStage !== undefined && importStage > fileStage) {
+            violations.push({
+                importPath: resolvedPath,
+                importStage,
+                fileStage
+            });
+        }
+    }
+
+    if (violations.length > 0) {
+        return {
+            filePath,
+            fileStage,
+            violations
+        };
+    }
+
+    return undefined;
+}
+
+async function main() {
+    let auditRoot = ".";
+    let rootDir = path.resolve(auditRoot);
+
+    console.log("Auditing import violations...");
+    console.log(`Root directory: ${rootDir}\n`);
+
+    let allFiles = getAllTypeScriptFiles(rootDir);
+    let allViolations: FileViolations[] = [];
+
+    for (let file of allFiles) {
+        let violations = checkFile(file, rootDir);
+        if (violations) {
+            allViolations.push(violations);
+        }
+    }
+
+    if (allViolations.length === 0) {
+        console.log("✓ No violations found!");
+        return;
+    }
+
+    console.log("VIOLATIONS FOUND:\n");
+    console.log("=".repeat(80));
+
+    for (let fileViolation of allViolations) {
+        console.log(`\n${fileViolation.filePath} (stage ${fileViolation.fileStage}):`);
+        for (let violation of fileViolation.violations) {
+            console.log(`  → imports ${violation.importPath} (stage ${violation.importStage})`);
+        }
+    }
+
+    console.log("\n" + "=".repeat(80));
+    console.log("\nSUMMARY:");
+    console.log(`Total files with violations: ${allViolations.length}`);
+    console.log(`Total violations: ${allViolations.reduce((sum, fv) => sum + fv.violations.length, 0)}`);
+
+    console.log("\nViolations per file:");
+    for (let fileViolation of allViolations) {
+        console.log(`  ${fileViolation.filePath}: ${fileViolation.violations.length} violation${fileViolation.violations.length === 1 ? "" : "s"}`);
+    }
+}
+
+main().catch(console.error).finally(() => process.exit(0));

package/src/diagnostics/listenOnDebugger.ts

@@ -9,7 +9,7 @@ import { lazy } from "socket-function/src/caching";
 
 let devToolsUrl = "";
 
-const listenOnDebugger = lazy(async function listenOnDebugger() {
+const listenOnDebugger = lazy(function listenOnDebugger() {
     if (devToolsUrl) return;
     if (!isNode()) return;
     // IMPORTANT! NEVER use the built-in port. This adds a tiny bit of security. Not much,
@@ -37,14 +37,14 @@ const listenOnDebugger = lazy(async function listenOnDebugger() {
         }
     }
 });
-export async function getDebuggerUrl() {
+export function getDebuggerUrl() {
     // NOTE: Very unfortunate, as this means that if a developer is debugging a server for a bit,
     //  the inspector is left open. It's kind of hard to tell when they are done though.
     //  - This is still somewhat secure, as only localhost can connect, but... having local network
     //      accessing turning into remote execution access isn't great (especially for developers,
     //      who could then get pwned just by clicking on a link).
     // TODO: The security of this can be improved, see NodeViewer.tsx:getExternalInspectURL
-    await listenOnDebugger();
+    listenOnDebugger();
     return devToolsUrl;
 }
 function doesProcessExist(pid: number) {