querysub 0.473.0 → 0.475.0

package/.claude/settings.local.json

@@ -24,7 +24,8 @@
       "mcp__node-debugger__listBreakpoints",
       "mcp__node-debugger__removeBreakpoint",
       "mcp__hottest__runTest",
-      "Bash(yarn test *)"
+      "Bash(yarn test *)",
+      "Bash(yarn ssh-a-claude *)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.473.0",
+  "version": "0.475.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -23,7 +23,8 @@
     "mcp": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts",
     "mc": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts --cwd D:/repos/qs-cyoa/",
     "mcp2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts",
-    "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/"
+    "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/",
+    "ssh-a-claude": "ssh root@a.querysubtest.com"
   },
   "bin": {
     "deploy": "./bin/deploy.js",
@@ -66,7 +67,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "socket-function": "^1.1.35",
+    "socket-function": "^1.1.36",
     "terser": "^5.31.0",
     "typesafecss": "^0.29.0",
     "yaml": "^2.5.0",

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

@@ -505,6 +505,8 @@ export class ArchivesBackblaze {
         return api;
     });
 
+    private currentReset: Promise<void> | undefined;
+
     // Keep track of when we last reset because of a 503
     private last503Reset = 0;
     // IMPORTANT! We must always CATCH AROUND the apiRetryLogic, NEVER inside of fnc. Otherwise we won't
@@ -532,14 +534,17 @@ export class ArchivesBackblaze {
                 ) && Date.now() - this.last503Reset > 60 * 1000) {
                 console.error(`[${context}] 503 error, waiting and resetting: ${err.message}`);
                 this.log(`[${context}] 503 error, waiting and resetting: ${err.message}`);
-                await delay(10 * 1000);
-                // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once.
-                if (Date.now() - this.last503Reset > 60 * 1000) {
-                    this.log(`[${context}] Resetting getAPI and getBucketAPI: ${err.message}`);
-                    this.last503Reset = Date.now();
-                    getAPI.reset();
-                    this.getBucketAPI.reset();
-                }
+                this.currentReset = this.currentReset || (async () => {
+                    await delay(10 * 1000);
+                    // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once.
+                    if (Date.now() - this.last503Reset > 60 * 1000) {
+                        this.log(`[${context}] Resetting getAPI and getBucketAPI: ${err.message}`);
+                        this.last503Reset = Date.now();
+                        getAPI.reset();
+                        this.getBucketAPI.reset();
+                    }
+                })().finally(() => this.currentReset = undefined);
+                await this.currentReset;
                 return this.apiRetryLogic(context, fnc, retries - 1);
             }
 

package/src/-c-identity/IdentityController.ts

@@ -20,6 +20,7 @@ import { red } from "socket-function/src/formatting/logColors";
 import { isNode } from "typesafecss";
 import { areNodeIdsEqual, getOwnNodeId, getOwnThreadId } from "../-f-node-discovery/NodeDiscovery";
 import { timeInMinute } from "socket-function/src/misc";
+import { isClient, isServer } from "../config2";
 
 // NOTE: This used to be small, but we cache this, so it would mean a node on startup would time out, and then we would refuse to talk to it ever again. So... this can't be small
 const MAX_CHANGE_IDENTITY_TIMEOUT = timeInMinute * 5;
@@ -239,8 +240,8 @@ const changeIdentityOnce = cacheWeak(async function changeIdentityOnce(connectio
         cert: threadKeyCert.cert.toString(),
         certIssuer: issuer.cert.toString(),
         mountedPort: getNodeIdLocation(SocketFunction.mountedNodeId)?.port,
-        debugEntryPoint: isNode() ? process.argv[1] : "browser",
-        clientIsNode: isNode(),
+        debugEntryPoint: isServer() ? process.argv[1] : "browser",
+        clientIsNode: isServer(),
     };
     let signature = sign(threadKeyCert, payload);
     await timeoutToError(

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -229,6 +229,7 @@ function onNodesChanged() {
 }
 
 let rootDiscoveryNodeId = "";
+/** IMPORTANT! This domain import is the querysub server. Usually this is going to be a local development server. However, you can use Node Discovery and use whatever Node you want. You don't need to know the node's machine ID. You just need to know its address.  */
 export function configRootDiscoveryLocation(config: {
     domain: string;
     port: number;
@@ -337,11 +338,13 @@ async function syncArchives() {
         console.info(`Synced node ids from archives`, { nodeIds });
         await setNodeIds(nodeIds);
     } else {
-        if (isNoNetwork() || !isNode()) {
+        if (isNoNetwork() || !isNode() || rootDiscoveryNodeId) {
             // NOTE: If no network, our trust source might be different, so we can't talk to regular nodes,
             //  and instead have to only talk to HTTP nodes
             await setNodeIds([getBrowserUrlNode()]);
         } else {
+            // NOTE: I don't think this pathway works. But in theory it should it should be possible for us in nodejs to automatically choose the server we want to talk to. In practice, it probably doesn't matter right now, as we're mostly just using this for development, in which case we want to force it to use the local server anyway, which will set root discovery node ID. 
+
             // If on the network, NetworkTrust2 should sync the trusted machines from backblaze, so we should be
             //  able to talk to any nodes.
             //  - If they user is using --client they only want to talk to querysub nodes. There might be multiple,
@@ -575,17 +578,33 @@ if (isServer()) {
 } else {
 
     if (isNode()) {
-        discoveryReady.resolve();
-        nodeBroadcasted.resolve();
-        // Just get the archives, syncing again if we haven't synced in a while
-        let lastGetTime = 0;
-        beforeGetNodeAllId = async () => {
-            let lastGetThreshold = lastGetTime + CLIENTSIDE_POLL_RATE;
-            if (Date.now() > lastGetThreshold) {
-                lastGetTime = Date.now();
-                await syncArchives();
-            }
-        };
+        if (rootDiscoveryNodeId) {
+            let nodes = [rootDiscoveryNodeId];
+            allNodeIds2 = new Set(nodes);
+            discoveryReady.resolve();
+            nodeBroadcasted.resolve();
+
+            // NOTE: We run into TLS issues (as in, our servers use self signed certs), if we try to talk to just
+            //  any node, so... we better just talk to the edge node
+            //  - We COULD probably just use some special domain (maybe JUST the machine domain?), with limited wildcard
+            //      certs (I think we can only wildcard a single depth anyways), and A records for the machines too...
+            //      but... having all traffic route through an edge node is probably better anyways...
+            nodeOverrides = nodes;
+
+        } else {
+            // NOTE: I don't think this pathway works. But in theory it should it should be possible for us in nodejs to automatically choose the server we want to talk to. In practice, it probably doesn't matter right now, as we're mostly just using this for development, in which case we want to force it to use the local server anyway, which will set root discovery node ID. 
+            discoveryReady.resolve();
+            nodeBroadcasted.resolve();
+            // Just get the archives, syncing again if we haven't synced in a while
+            let lastGetTime = 0;
+            beforeGetNodeAllId = async () => {
+                let lastGetThreshold = lastGetTime + CLIENTSIDE_POLL_RATE;
+                if (Date.now() > lastGetThreshold) {
+                    lastGetTime = Date.now();
+                    await syncArchives();
+                }
+            };
+        }
     } else {
         setImmediate(() => {
             let edgeNode = getBootedEdgeNode();

package/src/1-path-client/RemoteWatcher.ts

@@ -111,7 +111,7 @@ export class RemoteWatcher {
                 // NOTE: We keep around the old authorities in routing (for a few minutes), so if a new node doesn't start,
                 //  we will match the disconnected node again. This means we have a few minutes to start another server.
                 // TODO: Retry instead of throwing
-                console.log(yellow(`Trying to find new authority for disconnected watches ${paths.length} paths and ${parentPaths.length} parent paths`));
+                console.log(yellow(`Trying to find new authority for disconnected watches ${paths.length} paths and ${parentPaths.length} parent paths`), { authorityId });
                 logErrors(this.tryToReconnectNow());
             })());
             // Reconnection is our loop running again, maybe matching the same nodeId, and then using it again.

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1957,6 +1957,10 @@ export class PathValueProxyWatcher {
     public runOnce<Result = void>(
         options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
     ): Result {
+        // TODO: This is a recent change. We maybe should apply the user pass and options. However, we definitely don't want to call create watcher as that will apply our additional options, making it temporary, where this might actually be run inside of a non-temporary watcher like a render function. Which finally will break on commit finish because it'll think it's in a temporary function and subscribe to the wrong callback. 
+        if (this.inWatcher()) {
+            return options.watchFunction();
+        }
         let result: { result: Result } | { error: string } | undefined;
         let watcher = this.createWatcher({
             ...options,

package/src/4-deploy/git.ts

@@ -126,18 +126,52 @@ export const setGitRef = measureWrap(async function setGitRef(config: {
     gitRef: string;
 }) {
     await fs.promises.mkdir(config.gitFolder, { recursive: true });
-    let hostKey = await runPromise(`ssh-keyscan -t rsa bitbucket.org`);
-    hostKey = hostKey.split("\n").filter(x => !x.startsWith("#")).join("\n");
-    let knownHostsPath = os.homedir() + "/.ssh/known_hosts";
-    if (!fs.existsSync(knownHostsPath) || !fs.readFileSync(knownHostsPath).toString().includes(hostKey)) {
-        fs.appendFileSync(knownHostsPath, "\n" + hostKey + "\n");
+    // ssh-keyscan is a network call; a transient failure here must not abort the sync. The host key is normally already in known_hosts from machine setup, and callers only escalate to clobbering the checkout on *repo* failures — not on a momentary inability to refresh a host key.
+    try {
+        let hostKey = await runPromise(`ssh-keyscan -t rsa bitbucket.org`);
+        hostKey = hostKey.split("\n").filter(x => !x.startsWith("#")).join("\n");
+        let knownHostsPath = os.homedir() + "/.ssh/known_hosts";
+        if (hostKey && (!fs.existsSync(knownHostsPath) || !fs.readFileSync(knownHostsPath).toString().includes(hostKey))) {
+            fs.appendFileSync(knownHostsPath, "\n" + hostKey + "\n");
+        }
+    } catch (e: any) {
+        console.warn(`ssh-keyscan for bitbucket.org failed, continuing: ${e.stack ?? e}`);
     }
 
     await runPromise(`git remote update`, { cwd: config.gitFolder });
     await runPromise(`git add --all`, { cwd: config.gitFolder });
-    await runPromise(`git stash`, { cwd: config.gitFolder });
+    // nothrow: on a freshly re-initialized repo (rebuildGitFolder) there is no initial commit yet, so `git stash` errors. That's harmless — the `git reset --hard` below is what actually forces the working tree to the target ref.
+    await runPromise(`git stash`, { cwd: config.gitFolder, nothrow: true });
     await runPromise(`git fetch --all`, { cwd: config.gitFolder });
     await runPromise(`git reset --hard ${config.gitRef}`, { cwd: config.gitFolder });
     // Allows us to remove deleted objects from storage, ex, if we accidentally commit a 1GB, this deletes it, so we don't have to fix each server individually. Also I think the repo breaks if we go too long without pruning it?
     await runPromise(`git prune`, { cwd: config.gitFolder });
+});
+
+/** Recovers a broken repo WITHOUT disturbing the working-tree files. We delete only .git, re-init, re-add the remote, then let setGitRef's `git reset --hard` reconcile the tracked files to the ref. Untracked / gitignored files (notably node_modules, which is expensive to reinstall and may be open in a running service) are left exactly as they are. When the directory is empty this produces the same result as a fresh clone. */
+export const rebuildGitFolder = measureWrap(async function rebuildGitFolder(config: {
+    gitFolder: string;
+    repoUrl: string;
+    gitRef: string;
+}) {
+    await fs.promises.mkdir(config.gitFolder, { recursive: true });
+    await fs.promises.rm(config.gitFolder + ".git", { recursive: true, force: true });
+    await runPromise(`git init`, { cwd: config.gitFolder });
+    await runPromise(`git remote add origin ${config.repoUrl}`, { cwd: config.gitFolder });
+    await setGitRef({ gitFolder: config.gitFolder, gitRef: config.gitRef });
+});
+
+/** Last-resort recovery for a working tree git can't reconcile (rebuildGitFolder failed). Clones fresh into a sibling temp directory and swaps it in only after the clone and ref-set succeed, so a failed/interrupted clone can never leave the live folder empty — the failure mode that previously stranded running services with a deleted node_modules. This necessarily discards node_modules; the caller reinstalls it. */
+export const nuclearReclone = measureWrap(async function nuclearReclone(config: {
+    gitFolder: string;
+    repoUrl: string;
+    gitRef: string;
+}) {
+    let target = config.gitFolder.replace(/[\/\\]+$/, "");
+    let tempDir = target + ".reclone-" + Date.now();
+    await fs.promises.rm(tempDir, { recursive: true, force: true });
+    await runPromise(`git clone ${config.repoUrl} ${tempDir}`);
+    await setGitRef({ gitFolder: tempDir + "/", gitRef: config.gitRef });
+    await fs.promises.rm(target, { recursive: true, force: true });
+    await fs.promises.rename(tempDir, target);
 });

package/src/4-querysub/Querysub.ts

@@ -1053,7 +1053,7 @@ export class Querysub {
 
     public static async hostService(name: string, port = 0) {
         if (isClient()) {
-            throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead.`);
+            throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead. You MUST provide configRootDiscoveryLocation a valid nodeId. Which means either you do server selection manually, or if you are developing, just point it to "127-0-0-1.${getDomain()}:your local port here"`);
         }
         let times: {
             name: string;

package/src/4-querysub/querysubPrediction.ts

@@ -403,6 +403,7 @@ function getFunctionSpec(call: CallSpec): FunctionSpec | undefined {
             ModuleId: call.ModuleId,
             FunctionId: call.FunctionId,
         });
+        if (!obj && !Querysub.isAllSynced()) return undefined;
         if (!obj) throw new Error(`Function not referenced in deploy.ts ${call.DomainName}.${call.ModuleId}.${call.FunctionId}`);
         setGitURLMapping({ spec: obj.functionSpec, resolvedPath: obj.modulePath });
         return obj.functionSpec;

package/src/config.ts

@@ -5,6 +5,7 @@ import { MaybePromise } from "socket-function/src/types";
 import { parseArgsFactory } from "./misc/rawParams";
 import { lazy } from "socket-function/src/caching";
 import fs from "fs";
+import { SocketFunction } from "socket-function/SocketFunction";
 
 export const serverPort = 11748;
 
@@ -35,6 +36,12 @@ let yargObj = parseArgsFactory()
     .argv
     ;
 
+if (isNode()) {
+    if (yargObj.client) {
+        SocketFunction.ENABLE_CLIENT_MODE = true;
+    }
+}
+
 export function getRawFncFilter() {
     return yargObj.fncfilter;
 }

package/src/deployManager/machineApplyMainCode.ts

@@ -13,12 +13,12 @@ import { formatTime } from "socket-function/src/formatting/format";
 import { sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { isDefined } from "../misc";
 import { logLoadTime } from "../logModuleLoadTimes";
-import { delay, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { delay, retryFunctional, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import os from "os";
 import fs from "fs";
 import { spawn, ChildProcess } from "child_process";
 import { lazy } from "socket-function/src/caching";
-import { getGitRefLive, getGitURLLive, setGitRef } from "../4-deploy/git";
+import { getGitRefLive, getGitURLLive, setGitRef, rebuildGitFolder, nuclearReclone } from "../4-deploy/git";
 import { blue, green, magenta, red } from "socket-function/src/formatting/logColors";
 import { shutdown } from "../diagnostics/periodic";
 import { onServiceConfigChange, triggerRollingUpdate } from "./machineController";
@@ -607,24 +607,53 @@ const killScreen = measureWrap(async function killScreen(config: {
     await runPromise(`${prefix}tmux kill-session -t ${config.screenName}`);
     await removeOldNodeId(config.screenName);
 });
+// When a present repo fails to sync, retry a few times with backoff before deciding it is actually broken — most failures are transient network blips (ssh-keyscan / fetch), and reacting to those by clobbering the checkout is what stranded running services (they kept running but crashed on the next lazy `require("ws")` once node_modules was gone).
+const GIT_SYNC_MAX_RETRIES = 4;
+const GIT_SYNC_RETRY_MIN_DELAY = timeInSecond * 2;
+const GIT_SYNC_RETRY_MAX_DELAY = timeInSecond * 30;
+
 const ensureGitSynced = measureWrap(async function ensureGitSynced(config: {
-    // Ensures existingFolder is the repo, as in, cwd to it, and git clone ., if needed. Reset the hash, in whatever way we need to, to force it to gitRef (git add --all and stash, etc, etc).
-    //  - Maybe ask the AI the best way to forcefully switch a git repo.
+    // Forces the checkout at gitFolder to gitRef. Escalates through increasingly destructive recoveries, but only ever destroys the working tree as an absolute last resort — a network blip must never wipe node_modules out from under a running service.
     gitFolder: string;
     repoUrl: string;
     gitRef: string;
 }) {
-    try {
-        if (!await fsExistsAsync(config.gitFolder + ".git")) {
-            await runPromise(`git clone ${config.repoUrl} ${config.gitFolder}`);
+    let hasGit = await fsExistsAsync(config.gitFolder + ".git");
+
+    // Repo present: sync to the ref, retrying transient failures with backoff. We do NOT clobber the checkout just because a network call blipped.
+    if (hasGit) {
+        try {
+            await retryFunctional(() => setGitRef(config), {
+                maxRetries: GIT_SYNC_MAX_RETRIES,
+                minDelay: GIT_SYNC_RETRY_MIN_DELAY,
+                maxDelay: GIT_SYNC_RETRY_MAX_DELAY,
+            })();
+            return;
+        } catch (e: any) {
+            console.error(`Failed to sync git ref after ${GIT_SYNC_MAX_RETRIES} retries; rebuilding .git in place next (working tree, incl. node_modules, is preserved).`, {
+                gitFolder: config.gitFolder,
+                repoUrl: config.repoUrl,
+                gitRef: config.gitRef,
+                error: e?.stack ?? String(e),
+            });
         }
-        await setGitRef(config);
+    }
+
+    // Repo missing, or present-but-unsyncable: rebuild just the .git metadata and let `git reset --hard` reconcile the tracked files. The working-tree files (node_modules) are left untouched. Equivalent to a clone when the folder is empty.
+    try {
+        await rebuildGitFolder(config);
+        return;
     } catch (e: any) {
-        console.warn(`Failed to set git ref, trying to delete and clone again (${config.gitFolder}): ${e.stack}`);
-        await fs.promises.rm(config.gitFolder, { recursive: true });
-        await runPromise(`git clone ${config.repoUrl} ${config.gitFolder}`);
-        await setGitRef(config);
+        console.error(`Rebuilding .git in place failed; falling back to a full delete + clone (this wipes node_modules, which the caller reinstalls).`, {
+            gitFolder: config.gitFolder,
+            repoUrl: config.repoUrl,
+            gitRef: config.gitRef,
+            error: e?.stack ?? String(e),
+        });
     }
+
+    // Nuclear: the working tree itself is unusable. Clone fresh (into a temp dir, swapped in only on success).
+    await nuclearReclone(config);
 });
 
 
@@ -710,8 +739,10 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                         gitRef: config.parameters.gitRef,
                     });
                     let afterGitRef = await getGitRefLive(gitFolder);
-                    if (afterGitRef !== prevGitRef) {
-                        console.log(green(`Yarn installing because git ref changed from ${prevGitRef} to ${afterGitRef} for ${magenta(screenName)}`));
+                    // Reinstall when the ref changed OR node_modules is missing. The latter is the real fix for the "Cannot find module 'ws'" crash: a recovery re-clone can land on the same commit, so a ref-only check would skip the install and leave the service with no node_modules. Restoring node_modules also self-heals an already-running process, since a failed `require` is never cached and the next reconnect re-resolves it.
+                    let nodeModulesMissing = !await fsExistsAsync(gitFolder + "node_modules");
+                    if (afterGitRef !== prevGitRef || nodeModulesMissing) {
+                        console.log(green(`Yarn installing for ${magenta(screenName)} (ref ${prevGitRef} -> ${afterGitRef}, nodeModulesMissing=${nodeModulesMissing})`));
                         await runPromise(`yarn install`, { cwd: gitFolder });
                     }
                 }

package/src/library-components/SyncedController.ts

@@ -1,4 +1,4 @@
-import { atomic, atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites, isTransparentValue, proxyWatcher, specialObjectWriteValue } from "../../src/2-proxy/PathValueProxyWatcher";
+import { atomic, atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites, doProxyOptions, isTransparentValue, proxyWatcher, specialObjectWriteValue } from "../../src/2-proxy/PathValueProxyWatcher";
 import { Querysub } from "../../src/4-querysub/Querysub";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { FullCallType, SocketRegistered } from "socket-function/SocketFunctionTypes";
@@ -91,6 +91,25 @@ const writeWatchers = new Map<string, {
     fncName: string;
 }[]>();
 
+export function asyncCache<T>(fnc: () => Promise<T>): (...args: any[]) => T | undefined {
+    return getSyncedController({
+        nodes: {
+            "": {
+                fnc,
+            },
+        },
+    })("").fnc;
+}
+export function asyncCacheObj<T>(fncs: T): {
+    [key in keyof T]: T[key] extends (...args: any[]) => Promise<infer Return> ? (...args: any[]) => Return | undefined : never;
+} {
+    return getSyncedController({
+        nodes: {
+            "": fncs as any,
+        },
+    })("") as any;
+}
+
 export function getSyncedController<T extends {
     nodes: {
         [key: string]: {
@@ -274,12 +293,15 @@ export function getSyncedController<T extends {
                         });
                         // We have to wait until we actually commit before making the call. Otherwise, if this commit is rejected because we need to do synchronized values, we'll call the function twice.
                         let fnc = controller.nodes[nodeId][fncName] as any;
+                        console.log(`Triggering call ${fncName} with args ${JSON.stringify(args)}`);
                         Querysub.onCommitFinished(() => {
-                            if (Querysub.isAllSynced()) {
-                                void Promise.resolve().then(() => {
-                                    doPromiseCall();
-                                });
-                            }
+                            console.log(`Commit finished for call ${fncName} with args ${JSON.stringify(args)}`);
+                            // Doesn't on commit finished also implicitly mean we're all synced? Pretty sure that isAll synced is making things break. 
+                            //if (Querysub.isAllSynced()) {
+                            void Promise.resolve().then(() => {
+                                doPromiseCall();
+                            });
+                            //}
                         });
                         function doPromiseCall() {
                             let promise = fnc(...args) as Promise<unknown>;
@@ -347,7 +369,10 @@ export function getSyncedController<T extends {
                                 }
                             }
                         }
+                        // Force it to commit, so even if we aren't synced, it runs.
+                        //doProxyOptions({ commitAllRuns: true }, () => {
                         call(...args);
+                        //});
                         // Assign to itself, to preset the type assumptions typescript makes (otherwise we get an error below)
                         obj = obj as any;
                         if (config?.cachePromiseCalls) {

package/src/user-implementation/UserPage.tsx

@@ -70,7 +70,7 @@ export class UserPage extends qreact.Component {
                     `}
                 </style>
                 <div class={css.vbox(20)}>
-                    <div class={css.fontSize(28)}>User Configuration {isViewingOther && <span>({userId})</span>}</div>
+                    <div class={css.fontSize(28)}>User Configuration {<span>({userId})</span>}</div>
                     {userObj.userId !== userId && <div class={css.fontSize(16)}>(Used does not exist)</div>}
                     <div class={css.vbox(4)}>
                         <div><b>Email</b> {userObj.email}</div>

package/src/user-implementation/userData.ts

@@ -532,7 +532,7 @@ export function getCurrentUser(config?: { ignoreImpersonate?: boolean; }): strin
         let impersonate = !config?.ignoreImpersonate && impersonateURL.value;
         if (impersonate) return impersonate;
     }
-    if (isNode() && Querysub.getCallerIP() === "127.0.0.1" && isRecovery()) {
+    if (isNode() && Querysub.getCallerIPAllowUndefined() === "127.0.0.1" && isRecovery()) {
         return "local";
     }
     const machineId = Querysub.getCallerMachineId();
@@ -1121,13 +1121,12 @@ function unbanUser(config: { userId: string }) {
 }
 
 /** Adds the current machine to the shared "service" account, which otherwise is impossible to login as. */
-export async function registerServicePermissions() {
+export async function nodeJSLoginToUser(userId: string) {
     const machineId = Querysub.getOwnMachineId();
     const ips = [await getExternalIP(), "127.0.0.1", "10.0.0.1"];
     let now = Date.now();
 
     await Querysub.commitSynced(() => {
-        const userId = "service";
         if (!(userId in data().users)) {
             data().users[userId] = {
                 userId,