querysub 0.327.0 → 0.329.0

package/bin/error-email.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// public, so we can connect to it from any node (for diagnostics, etc)
+process.argv.push("--public");
+process.argv.push("--nobreak");
+
+require("typenode");
+require("../src/diagnostics/logs/errorNotifications/errorDigestEmail.tsx");

package/bin/error-im.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// public, so we can connect to it from any node (for diagnostics, etc)
+process.argv.push("--public");
+process.argv.push("--nobreak");
+
+require("typenode");
+require("../src/diagnostics/logs/errorNotifications/errorDigests.tsx");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.327.0",
+  "version": "0.329.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -22,7 +22,7 @@
     "js-sha512": "^0.9.0",
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
-    "socket-function": "^0.136.0",
+    "socket-function": "^0.140.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.22.0",
     "yaml": "^2.5.0",
@@ -56,7 +56,8 @@
     "join-public": "./bin/join-public.js",
     "merge": "./bin/merge.js",
     "addsuperuser": "./bin/addsuperuser.js",
-    "setemailkey": "./bin/setemailkey.js"
+    "error-email": "./bin/error-email.js",
+    "error-im": "./bin/error-im.js"
   },
   "devDependencies": {
     "dependency-cruiser": "^12.11.0",

package/src/-a-archives/archivesBackBlaze.ts

@@ -11,6 +11,7 @@ import { formatNumber, formatTime } from "socket-function/src/formatting/format"
 import { blue, green, magenta } from "socket-function/src/formatting/logColors";
 import debugbreak from "debugbreak";
 import { onTimeProfile } from "../-0-hooks/hooks";
+import dns from "dns";
 
 export function hasBackblazePermissions() {
     return isNode() && fs.existsSync(getBackblazePath());
@@ -382,6 +383,7 @@ const getAPI = lazy(async () => {
         cancelLargeFile,
         getDownloadAuthorization,
         getDownloadURL,
+        apiUrl: auth.apiUrl,
     };
 });
 
@@ -520,12 +522,30 @@ export class ArchivesBackblaze {
                 // Eh... this might be bad, but... I think we just get random 400 errors. If this spams errors,
                 //  we can remove this line.
                 || err.stack.includes(`400 Bad Request`)
+                || err.stack.includes(`"no tomes available"`)
+                || err.stack.includes(`getaddrinfo ENOTFOUND`)
             ) {
                 this.log(err.message + " retrying in 5s");
                 await delay(5000);
                 return this.apiRetryLogic(fnc, retries - 1);
             }
 
+            if (err.stack.includes(`getaddrinfo ENOTFOUND`)) {
+                let urlObj = new URL(api.apiUrl);
+                let hostname = urlObj.hostname;
+                let lookupAddresses = await new Promise(resolve => {
+                    dns.lookup(hostname, (err, addresses) => {
+                        resolve(addresses);
+                    });
+                });
+                let resolveAddresses = await new Promise(resolve => {
+                    dns.resolve4(hostname, (err, addresses) => {
+                        resolve(addresses);
+                    });
+                });
+                console.error(`getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
+            }
+
             // If the error is that the authorization token is invalid, reset getBucketAPI and getAPI
             // If the error is that the bucket isn't found, reset getBucketAPI
             if (err.stack.includes(`"expired_auth_token"`)) {

package/src/-a-archives/archivesCborT.ts

@@ -0,0 +1,52 @@
+import { lazy } from "socket-function/src/caching";
+import { Archives } from "./archives";
+import { decodeCborx, encodeCborx } from "../misc/cloneHelpers";
+import { ArchiveT } from "./archivesJSONT";
+
+export function archiveCborT<T>(archives: () => Archives): ArchiveT<T> {
+    archives = lazy(archives);
+    async function get(key: string) {
+        let buffer = await archives().get(key);
+        if (!buffer) return undefined;
+        return decodeCborx(buffer) as T;
+    }
+    async function set(key: string, value: T) {
+        await archives().set(key, encodeCborx(value));
+    }
+    async function deleteFnc(key: string) {
+        await archives().del(key);
+    }
+    async function keys() {
+        return (await archives().find("")).map(value => value.toString());
+    }
+    async function values() {
+        let keysArray = await keys();
+        let results: T[] = [];
+        await Promise.all(keysArray.map(async key => {
+            let value = await get(key);
+            if (value) {
+                results.push(value);
+            }
+        }));
+        return results;
+    }
+    async function entries(): Promise<[string, T][]> {
+        let keysArray = await keys();
+        let results: [string, T][] = [];
+        await Promise.all(keysArray.map(async key => {
+            let value = await get(key);
+            if (value) {
+                results.push([key, value]);
+            }
+        }));
+        return results;
+    }
+    async function* asyncIterator(): AsyncIterator<[string, T]> {
+        for (let [key, value] of await entries()) {
+            yield [key, value];
+        }
+    }
+    return {
+        get, set, delete: deleteFnc, keys, values, entries, [Symbol.asyncIterator]: asyncIterator
+    };
+}

package/src/-a-archives/archivesDisk.ts

@@ -1,5 +1,5 @@
 import { isNode } from "socket-function/src/misc";
-import { getSubFolder } from "../fs";
+import { fsExistsAsync, getSubFolder } from "../fs";
 import fs from "fs";
 import { blue, red, yellow } from "socket-function/src/formatting/logColors";
 import { measureFnc } from "socket-function/src/profiling/measure";
@@ -65,8 +65,8 @@ class ArchivesDisk {
         // Don't create the drive (and also only add up to the last path, via slicing (0, i)
         for (let i = 1; i < fileNameParts.length; i++) {
             let dir = this.LOCAL_ARCHIVE_FOLDER + fileNameParts.slice(0, i).join("/");
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir);
+            if (!await fsExistsAsync(dir)) {
+                await fs.promises.mkdir(dir);
             }
         }
     }
@@ -91,7 +91,7 @@ class ArchivesDisk {
         if (storageDisabled) return;
         fileName = escapeFileName(fileName);
         await this.simulateLag();
-        if (!fs.existsSync(this.LOCAL_ARCHIVE_FOLDER + fileName)) return;
+        if (!await fsExistsAsync(this.LOCAL_ARCHIVE_FOLDER + fileName)) return;
         try {
             await fs.promises.unlink(this.LOCAL_ARCHIVE_FOLDER + fileName);
         } catch { }
@@ -222,7 +222,7 @@ class ArchivesDisk {
         let fileNames: string[] = [];
         let folderNames: string[] = [];
         async function readDir(dir: string) {
-            if (!fs.existsSync(dir)) {
+            if (!await fsExistsAsync(dir)) {
                 return;
             }
             try {

package/src/-a-archives/archivesJSONT.ts

@@ -1,7 +1,7 @@
 import { lazy } from "socket-function/src/caching";
 import { Archives } from "./archives";
 
-export type ArchiveJSONT<T> = {
+export type ArchiveT<T> = {
     get(key: string): Promise<T | undefined>;
     set(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
@@ -11,12 +11,12 @@ export type ArchiveJSONT<T> = {
     [Symbol.asyncIterator](): AsyncIterator<[string, T]>;
 };
 
-export function archiveJSONT<T>(archives: () => Archives): ArchiveJSONT<T> {
+export function archiveJSONT<T>(archives: () => Archives): ArchiveT<T> {
     archives = lazy(archives);
     async function get(key: string) {
         let buffer = await archives().get(key);
         if (!buffer) return undefined;
-        return JSON.parse(buffer.toString());
+        return JSON.parse(buffer.toString()) as T;
     }
     async function set(key: string, value: T) {
         await archives().set(key, Buffer.from(JSON.stringify(value)));
@@ -29,11 +29,25 @@ export function archiveJSONT<T>(archives: () => Archives): ArchiveJSONT<T> {
     }
     async function values() {
         let keysArray = await keys();
-        return Promise.all(keysArray.map(key => get(key)));
+        let results: T[] = [];
+        await Promise.all(keysArray.map(async key => {
+            let value = await get(key);
+            if (value) {
+                results.push(value);
+            }
+        }));
+        return results;
     }
     async function entries(): Promise<[string, T][]> {
         let keysArray = await keys();
-        return Promise.all(keysArray.map(async key => [key, await get(key)]));
+        let results: [string, T][] = [];
+        await Promise.all(keysArray.map(async key => {
+            let value = await get(key);
+            if (value) {
+                results.push([key, value]);
+            }
+        }));
+        return results;
     }
     async function* asyncIterator(): AsyncIterator<[string, T]> {
         for (let [key, value] of await entries()) {

package/src/-a-archives/archivesLimitedCache.ts

@@ -1,6 +1,9 @@
-import { formatNumber } from "socket-function/src/formatting/format";
+import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { Archives } from "./archives";
 import { cache } from "socket-function/src/caching";
+import { measureFnc } from "socket-function/src/profiling/measure";
+import { batchFunction, runInfinitePoll } from "socket-function/src/batching";
+import { timeInHour } from "socket-function/src/misc";
 
 interface FileInfo {
     writeTime: number;
@@ -8,36 +11,68 @@ interface FileInfo {
     size: number;
 }
 
+interface IndexData {
+    files: Record<string, FileInfo>;
+}
+
 class ArchivesLimitedCache {
     private baseArchives: Archives;
     private maxFiles: number;
     private maxSize: number;
     private cache = new Map<string, FileInfo>();
     private initialized = false;
+    private readonly indexPath = ".cache-index.json";
 
     constructor(baseArchives: Archives, config: { maxFiles: number; maxSize: number }) {
         this.baseArchives = baseArchives;
         this.maxFiles = config.maxFiles;
         this.maxSize = config.maxSize;
         this.initOptionalMethods();
+        this.initPeriodicSync();
     }
 
     public getDebugName(): string {
         return `limitedCache(${this.maxFiles}files,${Math.round(this.maxSize / (1024 * 1024))}MB)/${this.baseArchives.getDebugName()}`;
     }
 
-    private async ensureInitialized(): Promise<void> {
-        if (this.initialized) return;
-
-        // Load all files on first access
+    @measureFnc
+    private async rebuildCacheFromFiles(): Promise<void> {
         const allFiles = await this.baseArchives.findInfo("", { type: "files" });
+        const newCache = new Map<string, FileInfo>();
+
+        // Build map of actual files (excluding index file)
         for (const file of allFiles) {
-            this.cache.set(file.path, {
+            if (file.path === this.indexPath) continue;
+
+            newCache.set(file.path, {
                 writeTime: file.createTime,
-                accessTime: file.createTime,
+                accessTime: this.cache.get(file.path)?.accessTime ?? file.createTime,
                 size: file.size,
             });
         }
+
+        // Update cache with actual files
+        this.cache.clear();
+        for (const [path, info] of newCache.entries()) {
+            this.cache.set(path, info);
+        }
+    }
+
+    @measureFnc
+    private async ensureInitialized(): Promise<void> {
+        if (this.initialized) return;
+
+        // First try to load from index file
+        await this.loadIndex();
+
+        // If index is empty or missing, fall back to scanning all files
+        if (this.cache.size === 0) {
+            console.log("Index file missing or empty, scanning all files...");
+            await this.rebuildCacheFromFiles();
+            // Save the newly built index
+            await this.saveIndex();
+        }
+
         this.initialized = true;
 
         // Cleanup if we're already over limits
@@ -83,12 +118,18 @@ class ArchivesLimitedCache {
                 currentFiles--;
             }
         }
+
+        // Trigger index flush if any files were deleted
+        if (currentFiles < totalFiles) {
+            this.triggerIndexFlush();
+        }
     }
 
     private updateAccessTime(path: string): void {
         const info = this.cache.get(path);
         if (info) {
             info.accessTime = Date.now();
+            this.triggerIndexFlush();
         }
     }
 
@@ -109,12 +150,14 @@ class ArchivesLimitedCache {
             accessTime: now,
             size: data.length,
         });
+        this.triggerIndexFlush();
     }
 
     public async del(path: string): Promise<void> {
         await this.ensureInitialized();
         await this.baseArchives.del(path);
         this.cache.delete(path);
+        this.triggerIndexFlush();
     }
 
     public async getInfo(path: string): Promise<{ writeTime: number; size: number; } | undefined> {
@@ -164,6 +207,74 @@ class ArchivesLimitedCache {
     public getURL?: (path: string) => Promise<string>;
     public getDownloadAuthorization?: (config: { validDurationInSeconds: number }) => Promise<{ bucketId: string; fileNamePrefix: string; authorizationToken: string; }>;
 
+    private batchedFlushIndex = batchFunction(
+        { delay: 2000 }, // Flush index changes every 2 seconds
+        async () => {
+            // We don't actually need the batched values, just flush the index
+            await this.saveIndex();
+        }
+    );
+
+    private async loadIndex(): Promise<void> {
+        try {
+            const indexBuffer = await this.baseArchives.get(this.indexPath);
+            if (!indexBuffer) {
+                // No existing index, will need to build it
+                return;
+            }
+
+            const indexData: IndexData = JSON.parse(indexBuffer.toString("utf8"));
+
+            // Load the cache from the index
+            this.cache.clear();
+            for (const [path, info] of Object.entries(indexData.files)) {
+                this.cache.set(path, info);
+            }
+
+            console.log(`Loaded index with ${this.cache.size} files`);
+        } catch (error) {
+            console.warn(`Failed to load index file:`, error);
+            // Continue without index, will rebuild
+        }
+    }
+
+    private async saveIndex(): Promise<void> {
+        try {
+            const indexData: IndexData = {
+                files: Object.fromEntries(this.cache.entries())
+            };
+
+            const indexBuffer = Buffer.from(JSON.stringify(indexData), "utf8");
+            await this.baseArchives.set(this.indexPath, indexBuffer);
+        } catch (error) {
+            console.warn(`Failed to save index file:`, error);
+        }
+    }
+
+    private triggerIndexFlush(): void {
+        void this.batchedFlushIndex(undefined);
+    }
+
+    private initPeriodicSync(): void {
+        // Sync index with actual files every hour to prevent drift
+        runInfinitePoll(timeInHour, async () => {
+            await this.syncIndexWithFiles();
+        });
+    }
+
+    private async syncIndexWithFiles(): Promise<void> {
+        try {
+            console.log("Syncing index with actual files...");
+            await this.rebuildCacheFromFiles();
+
+            // Save updated index
+            await this.saveIndex();
+            console.log(`Index synced with ${this.cache.size} actual files`);
+        } catch (error) {
+            console.warn("Failed to sync index with files:", error);
+        }
+    }
+
     private initOptionalMethods(): void {
         this.getURL = this.baseArchives.getURL;
         this.getDownloadAuthorization = this.baseArchives.getDownloadAuthorization;

package/src/-a-archives/archivesPrivateFileSystem.ts

@@ -4,6 +4,7 @@ import { Archives } from "./archives";
 import { cache, lazy } from "socket-function/src/caching";
 import { delay } from "socket-function/src/batching";
 import { isDefined } from "../misc";
+import { formatTime } from "socket-function/src/formatting/format";
 
 let getRootDirectory = lazy(async () => {
     await navigator.storage.persist();
@@ -168,9 +169,11 @@ class ArchivesPrivateFileSystem {
         }
 
         try {
+            let readDirTime = Date.now();
             // Start from the root directory of our namespace
             const rootDirectory = await this.getOrCreateDirectory("");
             await readDir(rootDirectory, "");
+            console.log(`readDir took ${formatTime(Date.now() - readDirTime)}`);
 
             let results = config?.type === "folders" ? folderNames : fileNames;
             results = results.filter(name => name.startsWith(prefix));

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

@@ -16,6 +16,9 @@ import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { isNoNetwork } from "../config";
 import { getDebuggerUrl } from "../diagnostics/listenOnDebugger";
 import { hackDevtoolsWebsocketForward } from "./oneTimeForward";
+import { getOwnMachineId, decodeNodeId, decodeNodeIdAssert } from "../-a-auth/certs";
+import { sort } from "socket-function/src/misc";
+import { getPathStr2 } from "../path";
 
 let loadTime = Date.now();
 
@@ -71,25 +74,37 @@ export async function getControllerNodeIdList(
     controller: SocketRegistered<{}>,
 ): Promise<{ nodeId: string; entryPoint: string }[]> {
     let nodeIdsToTest = await getAllNodeIds();
-    let passedNodeIds = new Map<string, string>();
+    let passedNodeIds = new Map<string, { machineId: string; entryPoint: string }>();
     await Promise.all(nodeIdsToTest.map(async nodeId => {
-        if (await doesNodeExposeController(nodeId, controller)) {
-            let entryPoint = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[nodeId].getEntryPoint()) || "Entry point timedout";
-            passedNodeIds.set(nodeId, entryPoint);
+        let result = await doesNodeExposeController(nodeId, controller);
+        if (result) {
+            passedNodeIds.set(nodeId, result);
         }
     }));
 
-    let results = Array.from(passedNodeIds.entries()).map(([nodeId, entryPoint]) => ({ nodeId, entryPoint }));
-    // Ignore the special local IDs, otherwise we'll be returning duplicates. And our caller probably doesn't want the fastest path, they probably just want every path. 
-    // TODO: We should detect if the local ID and the remote ID is the same and then always pick the local ID instead. However, I have no idea how to do this as it doesn't include the machine ID, just the port. So how do we know if they're the same? I think we actually have to talk to them and identify their machine IDs, which we need to cache, which then takes longer, et cetera, et cetera. 
-    results = results.filter(x => !x.nodeId.startsWith("127-0-0-1."));
-    return results;
+    let results = Array.from(passedNodeIds.entries());
+    // Prefer localhost connections as they're faster.
+    sort(results, (x) => x[0].startsWith("127-0-0-1.") ? 0 : 1);
+    let lookup = new Map<string, { nodeId: string; entryPoint: string }>();
+    for (let x of results) {
+        let key = getPathStr2(x[1].machineId, decodeNodeIdAssert(x[0]).port.toString());
+        if (key in lookup) continue;
+        lookup.set(key, { nodeId: x[0], entryPoint: x[1].entryPoint });
+    }
+
+    return Array.from(lookup.values());
 }
 
 
-export async function doesNodeExposeController(reconnectNodeId: string, controller: SocketRegistered<{}>): Promise<boolean> {
+export async function doesNodeExposeController(reconnectNodeId: string, controller: SocketRegistered<{}>): Promise<{ machineId: string, entryPoint: string } | false> {
     let exposedControllers = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[reconnectNodeId].getExposedControllers());
-    return !!exposedControllers?.includes(controller._classGuid);
+    let machineId = await getOwnMachineId();
+    let entryPoint = await new NodeCapabilitiesControllerBase().getEntryPoint();
+
+    if (exposedControllers?.includes(controller._classGuid)) {
+        return { machineId, entryPoint };
+    }
+    return false;
 }
 
 const startupTime = Date.now();

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

@@ -3,6 +3,7 @@ import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { isDevDebugbreak } from "../config";
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { QueueLimited } from "socket-function/src/misc";
+import { isNode } from "typesafecss";
 
 export type DebugLog = {
     type: string;
@@ -12,7 +13,8 @@ export type DebugLog = {
 
 // NOTE: For now, this is actually fairly light, so we'll just turn it on by default. It is very useful
 //  in debugging synchronization issues.
-let ENABLED_LOGGING = true;
+// NOTE: Clientside it is not quite as light, so... don't turn it on clientside, as we don't really use it anyways.
+let ENABLED_LOGGING = isNode();
 export function enableAuditLogging() {
     ENABLED_LOGGING = true;
     debugLogFnc = debugLogBase;
@@ -25,7 +27,7 @@ export function isDebugLogEnabled() {
     return ENABLED_LOGGING;
 }
 
-let logHistory = new QueueLimited<DebugLog>(1000 * 1000 * 10);
+let logHistory = new QueueLimited<DebugLog>(1000 * 500);
 export function getFullLogHistory() {
     return logHistory;
 }

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -35,6 +35,7 @@ import { deepCloneCborx } from "../misc/cloneHelpers";
 import { formatPercent, formatTime } from "socket-function/src/formatting/format";
 import { addStatPeriodic, interceptCalls, onAllPredictionsFinished, onTimeProfile } from "../-0-hooks/hooks";
 import { onNextPaint } from "../functional/onNextPaint";
+import { isAsyncFunction } from "../misc";
 
 // TODO: Break this into two parts:
 //  1) Run and get accesses
@@ -212,6 +213,9 @@ export interface WatcherOptions<Result> {
     logSyncTimings?: boolean;
 
     maxLocksOverride?: number;
+
+    // NOTE: The reason there isn't throttle support here is very frequently when you want to throttle one component rendering, it's because you have many components. So you actually want to throttle many components and have them throttle in conjunction with each other, which results in the logic becoming complicated.
+    //  - But maybe we should support the single throttle case anyways?
 }
 
 let harvestableReadyLoopCount = 0;
@@ -972,6 +976,9 @@ export class PathValueProxyWatcher {
     public createWatcher<Result = void>(
         options: WatcherOptions<Result>
     ): SyncWatcher {
+        if (isAsyncFunction(options.watchFunction)) {
+            throw new Error(`Async functions are not supported in watchers. They must run the caller synchronously. You are likely not using Await anyway, so just remove the async and make it a synchronous function. The caller will be called again whenever the data you access changes, And if you are running this to return a result, it will be rerun until all the data you want is synchronized. Watch function: ${options.watchFunction.toString()}`);
+        }
         // NOTE: Setting an order is needed for rendering, so parents render before children. I believe
         //  it is generally what we want, so event triggering is consistent, and fits with any tree based
         //  watching system. If this causes problems we COULD remove it from here and have just qreact.tsx set it.

package/src/3-path-functions/PathFunctionRunner.ts

@@ -228,7 +228,7 @@ export class PathFunctionRunner {
 
         // Rarely we might need to queue a function multiple times, when we are late to receive rejections.
         //  HOWEVER, after enough times, we should stop, as we will probably just infinitely queue it.
-        const MAX_QUEUE_COUNT = 25;
+        const MAX_QUEUE_COUNT = 100;
         let queueLimitCounts = new Map<string, number>();
         // Clear every hour, so we don't leave
         runInfinitePoll(timeInHour, () => queueLimitCounts.clear());
@@ -323,7 +323,7 @@ export class PathFunctionRunner {
                         if (limitCount >= MAX_QUEUE_COUNT) {
                             // Only error the first time, as we don't need need that many errors
                             if (limitCount === MAX_QUEUE_COUNT) {
-                                console.error(`Queue limit reached (${limitCount}) for ${getDebugName(callData, functionSpec, true)}`);
+                                console.error(`Tried to requeue a function to run too many times (${limitCount}) for ${getDebugName(callData, functionSpec, true)}. This is NOT due to cascading reads. It might be due to repeated rejections?`);
                             }
                             continue;
                         }

package/src/4-querysub/Querysub.ts

@@ -770,7 +770,7 @@ export class Querysub {
             return `<script>${edgeBootstrapFile}</script>`;
         });
 
-        if (!noSyncing()) {
+        if (!noSyncing() && !isBootstrapOnly()) {
             SocketFunction.expose(QuerysubController);
         }
 

package/src/5-diagnostics/GenericFormat.tsx

@@ -1,4 +1,4 @@
-import { formatDateTime, formatNiceDateTime, formatNumber, formatPercent, formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+import { formatDateTime, formatDateTimeDetailed, formatNiceDateTime, formatNumber, formatPercent, formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { css } from "typesafecss";
 import { canHaveChildren } from "socket-function/src/types";
 import { qreact } from "../4-dom/qreact";
@@ -44,7 +44,7 @@ let formatters: { [formatter in StringFormatters]: (value: unknown) => preact.Co
     number: (value) => d(value, formatNumber(Number(value))),
     percent: (value) => d(value, formatPercent(Number(value))),
     timeSpan: (value) => d(value, formatTime(Number(value))),
-    date: (value) => d(value, formatVeryNiceDateTime(Number(value))),
+    date: (value) => d(value, <span title={formatDateTimeDetailed(Number(value))}>{formatVeryNiceDateTime(Number(value))}</span>),
     error: (value) => d(value, <span class={errorMessage}>{String(value)}</span>),
     toSpaceCase: (value) => d(value, toSpaceCase(String(value))),
     "<Selector>": (value) => d(value, <Selector {...JSON.parse(String(value).slice("<Selector>".length))} />),

package/src/config.ts

@@ -11,6 +11,7 @@ export const serverPort = 11748;
 let yargObj = parseArgsFactory()
     .option("nonetwork", { type: "boolean", desc: `Disables all network requirements. Reduces security, as this means we cannot use real certificates.` })
     .option("domain", { type: "string", desc: `Sets the domain` })
+    .option("emaildomain", { type: "string", desc: `Sets the domain to use for email` })
     .option("client", { type: "boolean", desc: `Drops permissions, acting as an unauthenticated node` })
     .option("authority", { type: "string", desc: `Defines the base paths we are an authority on (the domain is prepended to them). Either a file path to a JSON(AuthorityPath[]), or a base64 representation of the JSON(AuthorityPath[]).` })
     .option("nobreak", { type: "boolean", desc: "Do not break on errors. Safer to set this than to just not set debugbreak, as some places might break without checking debugbreak, but nobreak works at a level where it is always used." })
@@ -20,12 +21,15 @@ let yargObj = parseArgsFactory()
     .option("recovery", { type: "boolean", desc: `Allows any localhost connections to act like a superuser (and a trusted node), to help recover the database (as you need permission to access the snapshot page).` })
     // TODO: The bootstrapper is a single file. Maybe we shouldn't run the entire service just for that. Although... maybe it's fine, as services are light?
     .option("bootstraponly", { type: "boolean", desc: "Don't register as an edge node, so we serve the bootstrap files, but we don't need up to date code because we are not used for endpoints or the UI." })
+    .option("notifyemails", { type: "array", desc: "The emails to notify when errors occur." })
     .argv
     ;
-
-let querysubConfig = lazy((): {
+type QuerysubConfig = {
     domain?: string;
-} => {
+    emaildomain?: string;
+    notifyemails?: string[];
+};
+let querysubConfig = lazy((): QuerysubConfig => {
     if (!isNode()) throw new Error("querysubConfig is only available on the server");
     const path = "./querysub.json";
     if (!fs.existsSync(path)) {
@@ -54,6 +58,14 @@ export function getDomain() {
     return yargObj.domain || querysubConfig().domain || "querysub.com";
 }
 
+export function getEmailDomain() {
+    return yargObj.emaildomain || querysubConfig().emaildomain || getDomain();
+}
+
+export function getNotifyEmails() {
+    return Array.from(new Set([...(yargObj.notifyemails || []), ...(querysubConfig().notifyemails || [])]));
+}
+
 export function baseIsClient() {
     return !isNode() || yargObj.client;
 }