sliftutils 1.7.87 → 1.7.89

package/misc/https/hostServer.ts

@@ -8,9 +8,13 @@ import { delay } from "socket-function/src/batching";
 import { getExternalIP } from "socket-function/src/networking";
 import { forwardPort } from "socket-function/src/forwardPort";
 import { magenta } from "socket-function/src/formatting/logColors";
-import { getOwnMachineId, getThreadKeyCert, loadIdentityCA } from "./certs";
+import { getOwnMachineId, getThreadKeyCert, loadIdentityCA, getIdentityCA, createX509, generateKeyPair } from "./certs";
 import { generateCert, getAccountKey, parseCert } from "./httpsCerts";
 import { setRecord } from "./dns";
+import { setHostsEntry } from "./hostsFile";
+
+// A self-signed cert is signed by our own CA and never renews via ACME, so it gets a long life
+const SELF_SIGNED_LIFESPAN = 1000 * 60 * 60 * 24 * 365 * 10;
 
 // Renew somewhere randomly between 40% and 60% of the way through the cert lifetime. The random threshold staggers parallel processes on the same machine, so usually one process renews early, and the others see the renewed cert on disk (we re-read the disk before every renewal check) and never renew themselves.
 const RENEW_THRESHOLD_MIN = 0.4;
@@ -30,6 +34,10 @@ export type HostServerConfig = {
     setDNSRecord?: boolean;
     publicIp?: string;
     allowHostnames?: string[];
+    /** LAN-only: do NOT forward the port (no UPnP/NAT mapping), for a server reachable only on the local network. */
+    internal?: boolean;
+    /** Serve a TLS cert signed by this machine's CA instead of obtaining a real (ACME) one. See getFreshHTTPSCert. */
+    selfSigned?: boolean;
     /** When the port is busy (e.g. the previous deploy still holds it), mount on an alternate port instead (the socket server's built-in free-port scan), and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). */
     portFallback?: {
         /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
@@ -50,12 +58,18 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
 
     if (config.setDNSRecord) {
         let ip = config.publicIp || await getExternalIP();
-        await setRecord("A", domain, ip);
+        if (config.selfSigned) {
+            // A self-signed server uses no Cloudflare at all (no ACME challenge and no public DNS record), so we resolve the ip-domain through THIS machine's hosts file instead. Other machines that need to reach it must resolve the domain themselves (a real DNS record, or the same hosts entry).
+            setHostsEntry({ ip, hostname: domain });
+            setHostsEntry({ ip: "127.0.0.1", hostname: "127-0-0-1." + rootDomain });
+        } else {
+            await setRecord("A", domain, ip);
+        }
     }
 
-    let keyCert = await getFreshHTTPSCert(domain);
+    let keyCert = await getFreshHTTPSCert(domain, config.selfSigned);
     let certListeners: ((value: { key: string; cert: string }) => void)[] = [];
-    void runCertRenewalLoop(domain, newKeyCert => {
+    void runCertRenewalLoop(domain, config.selfSigned, newKeyCert => {
         keyCert = newKeyCert;
         for (let listener of certListeners) {
             listener(newKeyCert);
@@ -65,7 +79,8 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
     // With portFallback, a busy port is not an error: the underlying server scans for a free port instead (useAvailablePortIfPortInUse), and the nodeId tells us which port we actually got
     let nodeId = await SocketFunction.mount({
         public: true,
-        autoForwardPort: true,
+        // --internal servers are LAN-only, so we never open a port on the router
+        autoForwardPort: !config.internal,
         port,
         useAvailablePortIfPortInUse: !!config.portFallback,
         ...getThreadKeyCert(rootDomain),
@@ -93,7 +108,7 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
     if (fallback && servingPort !== port) {
         console.warn(`Port ${port} is in use (presumably by our predecessor); serving on alternate port ${servingPort} until it frees`);
         await fallback.onPortInUse?.();
-        void runMainPortAcquireLoop(domain, port, servingPort, fallback);
+        void runMainPortAcquireLoop(domain, port, servingPort, fallback, !!config.internal);
     }
     fallback?.onListening(servingPort, servingPort === port);
     console.log(magenta(`Hosting https://${domain}:${servingPort} (nodeId ${nodeId})`));
@@ -101,7 +116,7 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
 }
 
 // SocketFunction can only mount once per process, so "taking over" the main port is a raw TCP relay forwarding to our real listener - TLS/SNI passes straight through, and clients address servers by ip domain (wildcard negotiation), so the extra hop is invisible.
-async function runMainPortAcquireLoop(domain: string, mainPort: number, servingPort: number, fallback: NonNullable<HostServerConfig["portFallback"]>): Promise<void> {
+async function runMainPortAcquireLoop(domain: string, mainPort: number, servingPort: number, fallback: NonNullable<HostServerConfig["portFallback"]>, internal: boolean): Promise<void> {
     while (true) {
         await delay(fallback.getAcquireDelay());
         let acquired = await new Promise<boolean>(resolve => {
@@ -124,24 +139,35 @@ async function runMainPortAcquireLoop(domain: string, mainPort: number, servingP
         });
         if (acquired) {
             console.log(magenta(`Acquired main port ${mainPort} for https://${domain} (relaying to our listener on ${servingPort})`));
-            // The mount only forwarded OUR serving port; the main port needs its own mapping (the predecessor's mapping pointed at the same machine+port, but dies with it)
-            await forwardPort({ externalPort: mainPort, internalPort: mainPort });
+            // The mount only forwarded OUR serving port; the main port needs its own mapping (the predecessor's mapping pointed at the same machine+port, but dies with it). LAN-only (--internal) servers never open router ports.
+            if (!internal) {
+                await forwardPort({ externalPort: mainPort, internalPort: mainPort });
+            }
             fallback.onListening(mainPort, true);
             return;
         }
     }
 }
 
-function getCertDiskPath(domain: string) {
-    return os.homedir() + `/httpscert_${domain}.json`;
+// Self-signed certs cache under a distinct name, so switching a domain between ACME and self-signed never reads back the wrong kind
+function getCertDiskPath(domain: string, selfSigned?: boolean) {
+    return os.homedir() + `/httpscert_${selfSigned ? "selfsigned_" : ""}${domain}.json`;
 }
-function readCertFromDisk(domain: string): { key: string; cert: string } | undefined {
+function readCertFromDisk(domain: string, selfSigned?: boolean): { key: string; cert: string } | undefined {
     try {
-        return JSON.parse(fs.readFileSync(getCertDiskPath(domain), "utf8")) as { key: string; cert: string };
+        return JSON.parse(fs.readFileSync(getCertDiskPath(domain, selfSigned), "utf8")) as { key: string; cert: string };
     } catch {
         return undefined;
     }
 }
+
+// A TLS cert for `domain` signed by this machine's identity CA, presented as a chain (leaf + CA) so a client that trusts the CA validates it. The key part of the ip-domain scheme is unchanged: browsers ignore nameConstraints and validate the SAN + chain; a browser that hasn't trusted the CA prompts the user, who accepts it once (the trust-cert flow), and node peers trust it via the CA.
+function generateSelfSignedCert(domain: string): { key: string; cert: string } {
+    let rootDomain = domain.split(".").slice(-2).join(".");
+    let ca = getIdentityCA(rootDomain);
+    let leaf = createX509({ domain, issuer: ca, keyPair: generateKeyPair(), lifeSpan: SELF_SIGNED_LIFESPAN });
+    return { key: leaf.key.toString(), cert: leaf.cert.toString() + "\n" + ca.cert.toString() };
+}
 function getRenewTime(certPem: string, threshold: number) {
     let certObj = parseCert(certPem);
     let start = +new Date(certObj.validity.notBefore);
@@ -149,12 +175,19 @@ function getRenewTime(certPem: string, threshold: number) {
     return start + (end - start) * threshold;
 }
 
-/** Returns the cached HTTPS cert for the domain, creating/renewing it first if it is past this process's renewal threshold. Reads the disk cache on every call, so a renewal done by a parallel process is picked up instead of renewing again. */
-export async function getFreshHTTPSCert(domain: string): Promise<{ key: string; cert: string }> {
-    let keyCert = readCertFromDisk(domain);
+/** Returns the cached HTTPS cert for the domain, creating/renewing it first if it is past this process's renewal threshold. Reads the disk cache on every call, so a renewal done by a parallel process is picked up instead of renewing again. selfSigned: sign it with this machine's CA instead of getting a real ACME cert. */
+export async function getFreshHTTPSCert(domain: string, selfSigned?: boolean): Promise<{ key: string; cert: string }> {
+    let keyCert = readCertFromDisk(domain, selfSigned);
     if (keyCert && getRenewTime(keyCert.cert, renewThreshold) > Date.now()) {
         return keyCert;
     }
+    if (selfSigned) {
+        // Cached so the served cert is stable across restarts (a browser's accepted-certificate exception is per exact cert)
+        console.log(magenta(keyCert ? `Self-signed cert for ${domain} is expiring, regenerating` : `No self-signed cert on disk for ${domain}, creating one (signed by this machine's CA)`));
+        let generated = generateSelfSignedCert(domain);
+        fs.writeFileSync(getCertDiskPath(domain, true), JSON.stringify(generated));
+        return generated;
+    }
     if (keyCert) {
         console.log(magenta(`HTTPS cert for ${domain} is past ${(renewThreshold * 100).toFixed(0)}% of its lifetime, renewing`));
     } else {
@@ -176,12 +209,12 @@ export async function getFreshHTTPSCert(domain: string): Promise<{ key: string;
     return { key: keyCert.key, cert: keyCert.cert };
 }
 
-async function runCertRenewalLoop(domain: string, onNewCert: (keyCert: { key: string; cert: string }) => void) {
-    let lastCert = readCertFromDisk(domain)?.cert;
+async function runCertRenewalLoop(domain: string, selfSigned: boolean | undefined, onNewCert: (keyCert: { key: string; cert: string }) => void) {
+    let lastCert = readCertFromDisk(domain, selfSigned)?.cert;
     while (true) {
         await delay(CERT_CHECK_INTERVAL);
         try {
-            let keyCert = await getFreshHTTPSCert(domain);
+            let keyCert = await getFreshHTTPSCert(domain, selfSigned);
             if (keyCert.cert !== lastCert) {
                 lastCert = keyCert.cert;
                 console.log(magenta(`HTTPS cert for ${domain} updated, applying to running server`));

package/misc/https/hostsFile.d.ts

@@ -0,0 +1,7 @@
+/** Ensures the hosts file maps `hostname` to `ip` (adding our tagged line, or updating it/an existing line for the same hostname). Idempotent. Returns false, with a warning telling the user the line to add by hand, if the file can't be written (writing the hosts file needs admin/root). */
+export declare function setHostsEntry(config: {
+    ip: string;
+    hostname: string;
+}): boolean;
+/** Removes our managed entry for `hostname` (only lines we added, tagged with the marker). No-op if absent or the file can't be written. */
+export declare function removeHostsEntry(hostname: string): void;

package/misc/https/hostsFile.ts

@@ -0,0 +1,66 @@
+import fs from "fs";
+import os from "os";
+
+// Cross-platform hosts-file editing, WITHOUT any third-party dependency. The approach (per-platform path, platform line endings, space-separated "<ip> <hostname>" entries, update-matching-hostname-else-append) is the same one the widely-used `hostile` npm package uses - but that package pulls in several dependencies (once, split, @ljharb/through), so this reimplements the ~40 lines we actually need instead of importing them. Used with --selfSigned, where we resolve the ip-domain locally via the hosts file instead of a public (Cloudflare) DNS record. NOTE: a hosts entry only affects THIS machine, so a self-signed server reachable from other machines still needs those machines to resolve its domain (a real DNS record, or the same hosts entry).
+
+const WINDOWS = os.platform() === "win32";
+// The canonical hosts-file locations (same as hostile)
+const HOSTS_PATH = WINDOWS ? "C:/Windows/System32/drivers/etc/hosts" : "/etc/hosts";
+const EOL = WINDOWS ? "\r\n" : "\n";
+// Tags the lines we manage, so they are recognizable (and safe to rewrite/remove) without touching the user's own entries
+const MARKER = "# managed by sliftutils hostsFile";
+
+// The hostname of a line, or undefined for a blank/comment/malformed line. The marker is a comment, so it is stripped here too - matching works the same for our lines and the user's.
+function lineHostname(line: string): string | undefined {
+    let noComment = line.replace(/#.*/, "").trim();
+    if (!noComment) return undefined;
+    let parts = noComment.split(/\s+/);
+    if (parts.length < 2) return undefined;
+    return parts[1];
+}
+
+/** Ensures the hosts file maps `hostname` to `ip` (adding our tagged line, or updating it/an existing line for the same hostname). Idempotent. Returns false, with a warning telling the user the line to add by hand, if the file can't be written (writing the hosts file needs admin/root). */
+export function setHostsEntry(config: { ip: string; hostname: string }): boolean {
+    let { ip, hostname } = config;
+    let desired = `${ip} ${hostname} ${MARKER}`;
+    let lines: string[];
+    try {
+        lines = fs.readFileSync(HOSTS_PATH, "utf8").split(/\r?\n/);
+    } catch (e) {
+        console.error(`Could not read the hosts file ${HOSTS_PATH} to map ${hostname} -> ${ip}: ${(e as Error).stack ?? e}. Add this line yourself: ${ip} ${hostname}`);
+        return false;
+    }
+    // A trailing newline leaves a final "" - drop trailing blanks so we don't accumulate them, and re-add exactly one newline at the end when we write
+    while (lines.length && lines[lines.length - 1] === "") lines.pop();
+
+    let index = lines.findIndex(line => lineHostname(line) === hostname);
+    if (index >= 0) {
+        if (lines[index] === desired) return true;
+        lines[index] = desired;
+    } else {
+        lines.push(desired);
+    }
+    try {
+        fs.writeFileSync(HOSTS_PATH, lines.join(EOL) + EOL);
+    } catch (e) {
+        console.error(`Could not write the hosts file ${HOSTS_PATH} to map ${hostname} -> ${ip} (writing it needs admin/root): ${(e as Error).stack ?? e}. Add this line yourself: ${ip} ${hostname}`);
+        return false;
+    }
+    return true;
+}
+
+/** Removes our managed entry for `hostname` (only lines we added, tagged with the marker). No-op if absent or the file can't be written. */
+export function removeHostsEntry(hostname: string): void {
+    let lines: string[];
+    try {
+        lines = fs.readFileSync(HOSTS_PATH, "utf8").split(/\r?\n/);
+    } catch {
+        return;
+    }
+    let kept = lines.filter(line => !(line.includes(MARKER) && lineHostname(line) === hostname));
+    if (kept.length === lines.length) return;
+    while (kept.length && kept[kept.length - 1] === "") kept.pop();
+    try {
+        fs.writeFileSync(HOSTS_PATH, kept.join(EOL) + EOL);
+    } catch { }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.87",
+    "version": "1.7.89",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/render-utils/dist/observer.tsx.cache

@@ -1,4 +1,4 @@
-"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.observer = void 0;
 process.env.NODE_ENV = "production";
@@ -36,4 +36,4 @@ function observer(Constructor) {
 }
 exports.observer = observer;
 //# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "e0e7abcd5640a6bddad57729ac4d2990ec02f5c7da073c7f9033ee0405567fb7"; */
+ /* _JS_SOURCE_HASH = "66bf117905c840638829362c0f5010e30300b34621cecc47d4fbc18f0fe6fe54"; */

package/storage/ArchivesDisk.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, SetConfig } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, MoveFileConfig, SetConfig, SetLargeFileConfig } from "./IArchives";
 export declare class ArchivesDisk implements IArchives {
     private folder;
     constructor(folder: string);
@@ -21,6 +21,7 @@ export declare class ArchivesDisk implements IArchives {
     private filePath;
     set(key: string, data: Buffer, config?: SetConfig): Promise<string>;
     del(key: string, config?: DelConfig): Promise<void>;
+    move(config: MoveFileConfig): Promise<void>;
     get(key: string, config?: GetConfig): Promise<Buffer | undefined>;
     get2(key: string, config?: GetConfig): Promise<{
         data: Buffer;
@@ -34,11 +35,7 @@ export declare class ArchivesDisk implements IArchives {
     find(prefix: string, config?: FindConfig): Promise<string[]>;
     findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]>;
     private collectFiles;
-    setLargeFile(config: {
-        path: string;
-        lastModified?: number;
-        getNextData(): Promise<Buffer | undefined>;
-    }): Promise<void>;
+    setLargeFile(config: SetLargeFileConfig): Promise<void>;
     startLargeUpload(): Promise<string>;
     appendLargeUpload(id: string, data: Buffer): Promise<void>;
     finishLargeUpload(id: string, key: string, lastModified?: number): Promise<void>;

package/storage/ArchivesDisk.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { lazy } from "socket-function/src/caching";
 import { runInfinitePoll } from "socket-function/src/batching";
 import { sort, binarySearchBasic } from "socket-function/src/misc";
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, SetConfig, assertValidLastModified } from "./IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, MoveFileConfig, SetConfig, SetLargeFileConfig, assertValidLastModified } from "./IArchives";
 import { filterChanges } from "./remoteStorage/remoteConfig";
 
 // The base file-system IArchives: storage is one-to-one with the file system, every key is exactly one real file under <folder>/files, so the file system itself is the index. File handles are cached and reused, and closed once idle (see FileHandleCache). All operations on a file run in serial, so they can't collide with each other or with handle closing. Used as the disk synchronization source of BlobStore (see remoteStorage/blobStore.ts).
@@ -191,6 +191,29 @@ export class ArchivesDisk implements IArchives {
         });
     }
 
+    public async move(config: MoveFileConfig): Promise<void> {
+        await this.init();
+        if (config.fromPath === config.toPath) return;
+        let fromPath = this.filePath(config.fromPath);
+        let toPath = this.filePath(config.toPath);
+        await this.handles.run(fromPath, async () => {
+            await this.handles.closeNow(fromPath);
+            await this.handles.run(toPath, async () => {
+                await this.handles.closeNow(toPath);
+                await fs.promises.mkdir(path.dirname(toPath), { recursive: true });
+                try {
+                    await fs.promises.rename(fromPath, toPath);
+                } catch (e: any) {
+                    if (e.code !== "ENOENT") throw e;
+                    throw new Error(`Cannot move ${JSON.stringify(config.fromPath)} to ${JSON.stringify(config.toPath)} on ${this.getDebugName()}: the source file does not exist`);
+                }
+                // The rename preserves the mtime, but a move must stamp FRESH (see IArchives.move) - the old stamp is how a moved file loses to a stale tombstone at its new path
+                let now = new Date();
+                await fs.promises.utimes(toPath, now, now);
+            });
+        });
+    }
+
     public async get(key: string, config?: GetConfig): Promise<Buffer | undefined> {
         let result = await this.get2(key, config);
         return result && result.data || undefined;
@@ -276,7 +299,8 @@ export class ArchivesDisk implements IArchives {
         }
     }
 
-    public async setLargeFile(config: { path: string; lastModified?: number; getNextData(): Promise<Buffer | undefined> }): Promise<void> {
+    // The raw disk has no windows, routes, or immutability, so the rest of the SetConfig has nothing to apply to here (the store wrapping this disk is what enforces them)
+    public async setLargeFile(config: SetLargeFileConfig): Promise<void> {
         let id = await this.startLargeUpload();
         try {
             while (true) {

package/storage/BulkDatabase2/BulkDatabaseReader.ts

@@ -164,7 +164,7 @@ export class BulkDatabaseReader<T extends { key: string }> {
         return { key, value: r.value as T[C], time: r.time };
     }
 
-    // ── sync (reactive) reads ────────────────────────────────────────────────────────────────────────
+    // ── synchronized (reactive) reads ────────────────────────────────────────────────────────────────────────
     getSingleFieldSync<C extends keyof T>(key: string, column: C): T[C] | undefined {
         return this.getSingleFieldObjSync(key, column)?.value;
     }