querysub 0.312.0 → 0.313.0

package/src/diagnostics/managementPages.tsx

@@ -28,7 +28,7 @@ import { addComponentButton } from "../5-diagnostics/qreactDebug";
 import { closeAllModals } from "../5-diagnostics/Modal";
 import { delay } from "socket-function/src/batching";
 
-const LogNotify = createLazyComponent(() => import("./errorLogs/LogNotify"))("LogNotify");
+const ErrorWarning = createLazyComponent(() => import("./logs/errorNotifications/ErrorWarning"))("ErrorWarning");
 
 export const managementPageURL = new URLParam("managementpage", "");
 export const showingManagementURL = new URLParam("showingmanagement", false);
@@ -63,6 +63,9 @@ export async function registerManagementPages2(config: {
         title?: string;
     }[];
 }) {
+    // Wait, so this happens asynchronously
+    await delay(0);
+
     if (registeredModule) {
         if (registeredModule === config.module) return;
         throw new Error(`registerManagementPages2 called with a different module than previously registered. This will break isManagementUser, and so is not allowed.`);
@@ -84,20 +87,8 @@ export async function registerManagementPages2(config: {
     });
     inputPages.push({
         title: "Logs",
-        componentName: "DiskLoggerPage",
-        controllerName: "DiskLoggerController",
-        getModule: () => import("./logs/DiskLoggerPage"),
-    });
-    inputPages.push({
-        title: "Error Notifications",
-        componentName: "LogViewer",
-        controllerName: "LogViewerController",
-        getModule: () => import("./errorLogs/LogViewer"),
-    });
-    inputPages.push({
-        title: "Error Classes",
-        componentName: "LogClassifiers",
-        getModule: () => import("./errorLogs/LogClassifiers"),
+        componentName: "LogViewer2",
+        getModule: () => import("./logs/LogViewer2"),
     });
     inputPages.push({
         title: "Audit Paths",
@@ -319,7 +310,7 @@ class ManagementRoot extends qreact.Component {
                         `}
                     </style>
                     <div class={css.fillWidth.hbox(30, 10).wrap.hsl(245, 25, 60).pad2(10).pointerEvents("all")}>
-                        <LogNotify />
+                        <ErrorWarning />
                         {pages.map(page =>
                             <ATag values={[{ param: managementPageURL, value: page.componentName }]}>{page.title}</ATag>
                         )}

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

@@ -10,7 +10,6 @@ import { formatNumber, formatPercent, formatTime } from "socket-function/src/for
 import { nextId, sort } from "socket-function/src/misc";
 import { ATag } from "../../library-components/ATag";
 import { managementPageURL, showingManagementURL } from "../../diagnostics/managementPages";
-import { filterURL } from "../../diagnostics/logs/DiskLoggerPage";
 import { watchShowLocalPaths, watchValueType } from "./LocalWatchViewer";
 import { filtersURL, viewMode } from "./archiveViewerShared";
 import { proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";

package/src/diagnostics/periodic.ts

@@ -6,6 +6,11 @@ import { nodeDiscoveryShutdown } from "../-f-node-discovery/NodeDiscovery";
 import { authorityStorage } from "../0-path-value-core/pathValueCore";
 import { red } from "socket-function/src/formatting/logColors";
 
+// Import querysub, so all the hooks we use will exist at some point
+setImmediate(async () => {
+    await import("../4-querysub/QuerysubController");
+});
+
 let periodicFncs: (() => void)[] = [];
 export function registerPeriodic(fnc: () => void) {
     periodicFncs.push(fnc);

package/src/diagnostics/watchdog.ts

@@ -6,10 +6,10 @@ import debugbreak from "debugbreak";
 import { registerPeriodic } from "./periodic";
 import { getOwnMachineId } from "../-a-auth/certs";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { logDisk } from "./logs/diskLogger";
 import { formatPercent, formatTime } from "socket-function/src/formatting/format";
 import { pathWatcher } from "../0-path-value-core/pathValueCore";
 import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, registerNodeMetadata } from "../-0-hooks/hooks";
+import { logDisk } from "./logs/diskLogger";
 
 let lastProfile: MeasureProfile | undefined;
 
@@ -72,7 +72,7 @@ function logProfileMeasuresTimingsNow() {
     measureObj = startMeasure();
     function diskLogMeasureObj(table: FormattedMeasureTable | undefined) {
         if (!table) return;
-        logDisk(table.title, table.entries);
+        logDisk("log", table.title, { entries: table.entries });
     }
     diskLogMeasureObj(logMeasureTable(profile, {
         name: `watchdog at ${new Date().toLocaleString()}`,

package/src/functional/SocketChannel.ts

@@ -0,0 +1,67 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { lazy } from "socket-function/src/caching";
+import { getAllNodeIds, watchNodeIds } from "../-f-node-discovery/NodeDiscovery";
+import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
+import { errorToUndefinedSilent } from "../errors";
+import { assertIsManagementUser } from "../diagnostics/managementPages";
+
+export class SocketChannel<T> {
+    constructor(private globalUniqueChannelName: string) { }
+    private controller = SocketFunction.register(
+        this.globalUniqueChannelName,
+        // Why do we have to cast here? Odd...
+        () => this as {
+            _internal_onMessage: (message: T) => Promise<void>;
+            _internal_watchMessages: () => Promise<void>;
+        },
+        () => ({
+            _internal_onMessage: { hooks: [assertIsManagementUser] },
+            _internal_watchMessages: { hooks: [assertIsManagementUser] },
+        }),
+    );
+
+    private localWatchers = new Set<(message: T) => void>();
+    // Has to be public for SocketFunction, don't call this externally
+    public async _internal_onMessage(message: T) {
+        for (let watcher of this.localWatchers) {
+            // Ignore errors (let the unhandled promise rejection handler log them)
+            void (async () => {
+                await watcher(message);
+            })();
+        }
+    }
+
+    private remoteWatchers = new Set<string>();
+    public async _internal_watchMessages() {
+        let caller = SocketFunction.getCaller();
+        this.remoteWatchers.add(caller.nodeId);
+        SocketFunction.onNextDisconnect(caller.nodeId, () => {
+            this.remoteWatchers.delete(caller.nodeId);
+        });
+    }
+
+    public broadcast(message: T) {
+        void Array.from(this.remoteWatchers).map(async (nodeId) => {
+            try {
+                await this.controller.nodes[nodeId]._internal_onMessage(message);
+            } catch {
+                this.remoteWatchers.delete(nodeId);
+            }
+        });
+    }
+
+    private watchAllNodes = lazy(async () => {
+        watchNodeIds((nodeIds) => {
+            for (let nodeId of nodeIds) {
+                void errorToUndefinedSilent(this.controller.nodes[nodeId]._internal_watchMessages());
+            }
+        });
+    });
+    public watch(callback: (message: T) => void) {
+        void this.watchAllNodes();
+        this.localWatchers.add(callback);
+        return () => {
+            this.localWatchers.delete(callback);
+        };
+    }
+}

package/src/library-components/Input.tsx

@@ -27,7 +27,7 @@ export type InputProps = (
         noEnterKeyCommit?: boolean;
         noFocusSelect?: boolean;
         inputKey?: string;
-        fillWidth?: boolean;
+        fillWidth?: boolean | number;
 
         /** By default, we don't accept value updates when focused. This prevents the user's
          *      typing from being interrupted by a value update. However, this flag will

package/src/library-components/InputLabel.tsx

@@ -27,7 +27,7 @@ export type InputLabelProps = Omit<InputProps, "label" | "title"> & {
 
     tooltip?: string;
 
-    fillWidth?: boolean;
+    fillWidth?: boolean | number;
 };
 
 function roundToDecimals(value: number, decimals: number) {
@@ -152,7 +152,10 @@ export class InputLabel extends qreact.Component<InputLabelProps> {
                 + " trigger-hover "
                 + props.outerClass
                 + (props.flavor === "large" && css.fontSize(18, "soft"))
-                + (props.fillWidth && css.fillWidth)
+                + (props.fillWidth &&
+                    css.flexGrow(typeof props.fillWidth === "number" ? props.fillWidth : 1)
+                        .alignSelf("stretch")
+                )
             }>
                 <div
                     class={

package/src/misc.ts

@@ -1,3 +1,5 @@
+import { canHaveChildren } from "socket-function/src/types";
+
 // TIMING: About 20MB/s
 export function createRandomText(count: number): string {
     let text = "";
@@ -61,4 +63,113 @@ export function mostCommon<T>(array: T[]): T | undefined {
         counts.set(item, (counts.get(item) || 0) + 1);
     }
     return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+
+
+export function parsePath(path: string): { dir: string; name: string } {
+    path = path.replaceAll("\\", "/");
+    let lastSlash = path.lastIndexOf("/");
+    if (lastSlash === -1) return { dir: "", name: path };
+    return { dir: path.slice(0, lastSlash + 1), name: path.slice(lastSlash + 1) };
+}
+
+// Loses spaces in keys and values
+export function toFileNameKVP(kvp: { [key: string]: string }): string {
+    function s(v: string) {
+        return v.replaceAll(" ", "_");
+    }
+    return "   " + Object.entries(kvp).map(([key, value]) => `${s(key)}=${s(value)}`).join("   ") + "   ";
+}
+export function parseFileNameKVP(fileName: string): { [key: string]: string } {
+    let parts = fileName.trim().split("   ");
+    let obj: { [key: string]: string } = {};
+    for (let part of parts) {
+        let [key, value] = part.split("=");
+        obj[key] = value || key;
+    }
+    return obj;
+}
+
+/** Copied object until maxFields is reached. */
+export function partialCopyObject(data: unknown, maxFields: number = 500): unknown {
+    try {
+        let fieldCount = 0;
+        const seen = new WeakSet();
+
+        function copy(value: unknown): unknown {
+            // Handle primitives
+            if (!canHaveChildren(value)) {
+                return value;
+            }
+
+            // Check for circular references
+            if (seen.has(value as object)) {
+                return null;
+            }
+            seen.add(value as object);
+
+            // Check if we've hit the field limit
+            if (fieldCount >= maxFields) {
+                return null;
+            }
+
+            if (Array.isArray(value)) {
+                const result: unknown[] = [];
+                for (const item of value) {
+                    fieldCount++;
+                    if (fieldCount >= maxFields) break;
+                    result.push(copy(item));
+                }
+                seen.delete(value);
+                return result;
+            }
+
+            // Handle plain objects
+            const result: Record<string, unknown> = {};
+            for (const key of Object.keys(value as object)) {
+                fieldCount++;
+                if (fieldCount >= maxFields) break;
+                result[key] = copy((value as Record<string, unknown>)[key]);
+            }
+            seen.delete(value);
+            return result;
+        }
+
+        return copy(data) as any;
+    } catch (e: any) {
+        return { errorCopying: e.messsage } as any;
+    }
+}
+
+export function sum(array: number[]): number {
+    return array.reduce((a, b) => a + b, 0);
+}
+
+export function matchFilter(filter: { value: string }, value: string) {
+    let filterValue = filter.value.toLowerCase().trim();
+    if (!filterValue) return true;
+    value = value.toLowerCase().trim();
+    return filterValue.split("|").some(part =>
+        part.split("&").every(part =>
+            value.includes(part.trim())
+        )
+    );
+}
+export const applyFilter = matchFilter;
+
+
+export function streamToIteratable<T>(reader: {
+    read(): Promise<{ value: T; done: false } | { done: true; value?: T }>;
+}): AsyncIterable<T> {
+    return {
+        [Symbol.asyncIterator]: async function* () {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                yield value;
+            }
+        }
+    };
 }

package/src/src.d.ts

@@ -1 +1,34 @@
-/// <reference path="./-a-auth/node-forge-ed25519.d.ts" />
+/// <reference path="./-a-auth/node-forge-ed25519.d.ts" />
+
+interface FileSystemDirectoryHandle {
+    [Symbol.asyncIterator](): AsyncIterator<[string, FileSystemFileHandle | FileSystemDirectoryHandle]>;
+    requestPermission(config: { mode: "read" | "readwrite" }): Promise<void>;
+}
+
+interface FileSystemFileHandle {
+    getFile(): File;
+    createWritable(): FileSystemWritableFileStream;
+    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
+}
+
+interface FileSystemSyncAccessHandle {
+    read(buffer: ArrayBuffer | ArrayBufferView, options?: { at: number }): number;
+    write(buffer: ArrayBuffer | ArrayBufferView, options?: { at: number }): number;
+    truncate(newSize: number): void;
+    flush(): void;
+    close(): void;
+}
+
+interface Window {
+    showSaveFilePicker(config?: {
+        types: {
+            description: string; accept: { [mimeType: string]: string[] }
+        }[];
+    }): Promise<FileSystemFileHandle>;
+    showDirectoryPicker(): Promise<FileSystemDirectoryHandle>;
+    showOpenFilePicker(config?: {
+        types: {
+            description: string; accept: { [mimeType: string]: string[] }
+        }[];
+    }): Promise<FileSystemFileHandle[]>;
+}

package/src/user-implementation/userData.ts

@@ -16,6 +16,7 @@ import { delay } from "socket-function/src/batching";
 import { enableErrorNotifications } from "../library-components/errorNotifications";
 import { clamp } from "../misc";
 import { sha256 } from "js-sha256";
+import { logDisk } from "../diagnostics/logs/diskLogger";
 
 /*
     IMPORTANT!
@@ -606,7 +607,7 @@ function sendLoginEmail(config: {
             );
             if (alreadyAllowed) {
                 data().machineSecure[machineId].userId = userId;
-                console.info(`User ${userId} already allowed for current ip and machine id, no need to send email.`);
+                logDisk("log", `User ${userId} already allowed for current ip and machine id, no need to send email.`);
                 return;
             }
         }
@@ -780,14 +781,14 @@ function inviteUser(config: { email: string }) {
     Querysub.ignorePermissionsChecks(() => {
         let curUserObj = getUserObjAssert();
         if (config.email in curUserObj.invitedUsers2) {
-            console.info(`User ${config.email} already invited`);
+            logDisk("log", `User ${config.email} already invited`);
             return;
         }
         // If the user already exists, don't invite
         const { email } = config;
         let userId = atomic(data().secure.emailToUserId[email]) || createNewUserId();
         if (userId in data().users) {
-            console.info(`User ${userId} already exists, no need to invite`);
+            logDisk("log", `User ${userId} already exists, no need to invite`);
             return;
         }
 

package/test.ts

@@ -0,0 +1,13 @@
+import { Querysub } from "./src/4-querysub/QuerysubController";
+// Import querysub, so inject is run
+Querysub;
+import { formatTime } from "socket-function/src/formatting/format";
+import { getMachineId, getOwnMachineId } from "./src/-a-auth/certs";
+import { testLogs } from "./src/diagnostics/logs/LogViewer2";
+import { shutdown } from "./src/diagnostics/periodic";
+import crypto from "crypto";
+import { testMain } from "./testEntry2";
+
+testMain().catch(console.error).finally(() => {
+    process.exit(0);
+});

package/testEntry2.ts

@@ -0,0 +1,29 @@
+import { delay } from "socket-function/src/batching";
+import { getOwnMachineId } from "./src/-a-auth/certs";
+import { getOwnThreadId } from "./src/-f-node-discovery/NodeDiscovery";
+import { shutdown } from "./src/diagnostics/periodic";
+
+export async function testMain() {
+    await delay(0);
+    console.log(getOwnThreadId());
+    console.error(`Test warning for ErrorWarning testing`);
+    console.log(getOwnThreadId());
+    await shutdown();
+    //await Querysub.hostService("test");
+    // for (let i = 0; i < 1000 * 10; i++) {
+    //     for (let j = 0; j < 1000; j++) {
+    //         testLogs.append({
+    //             time: Date.now(),
+    //             message: `Test message ${i}`,
+    //             randomString: crypto.randomBytes(16).toString(),
+    //             randomValue: Math.random(),
+    //         });
+    //     }
+    //     await testLogs.flushNow();
+    // }
+    // await shutdown();
+}
+async function main() {
+
+}
+