querysub 0.460.0 → 0.462.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.460.0",
+  "version": "0.462.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -66,7 +66,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "socket-function": "^1.1.33",
+    "socket-function": "^1.1.34",
     "terser": "^5.31.0",
     "typesafecss": "^0.29.0",
     "yaml": "^2.5.0",

package/src/-b-authorities/dnsAuthority.ts

@@ -1,7 +1,7 @@
 import os from "os";
 import * as fs from "fs";
 import { cache, lazy } from "socket-function/src/caching";
-import { isNode, isNodeTrue } from "socket-function/src/misc";
+import { isNode, isNodeTrue, timeInDay } from "socket-function/src/misc";
 import { httpsRequest } from "../https";
 import { getStorageDir } from "../fs";
 import { SocketFunction } from "socket-function/SocketFunction";
@@ -17,6 +17,8 @@ const DNS_TTLSeconds = {
     "A": 60,
 };
 
+const DNS_REFRESH_STALE_AFTER = timeInDay;
+
 export const hasDNSWritePermissions = lazy(async () => {
     if (!isNode()) return false;
     if (isClient()) return false;
@@ -53,6 +55,7 @@ export async function getRecordsRaw(type: string, key: string) {
         name: string;
         content: string;
         proxied: boolean;
+        modified_on: string;
     }[]>(`/zones/${zoneId}/dns_records`);
     return results.filter(x => x.type === type && x.name === key);
 }
@@ -86,7 +89,8 @@ export async function setRecord(type: string, key: string, value: string, proxie
     let prevValues = await getRecordsRaw(type, key);
     // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
     //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
-    if (prevValues.some(x => x.content === value)) return;
+    let alreadyExisted = prevValues.some(x => x.content === value);
+    if (alreadyExisted && Date.now() - new Date(prevValues.find(x => x.content === value)!.modified_on).getTime() < DNS_REFRESH_STALE_AFTER) return;
 
     console.log(magenta(`Removing previous records of ${type} for ${key} ${JSON.stringify(prevValues.map(x => x.content))}`));
     let didDeletions = false;
@@ -104,14 +108,15 @@ export async function setRecord(type: string, key: string, value: string, proxie
         ttl,
         proxied: proxied === "proxied",
     });
-    // NOTE: Apparently... even if the record didn't exist, we still have to wait...
-    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
-    for (let ttlLeft = ttl; ttlLeft > 0; ttlLeft--) {
-        await delay(1000);
-        console.log(`${ttlLeft} seconds left...`);
+    if (!alreadyExisted) {
+        // NOTE: Apparently... even if the record didn't exist, we still have to wait...
+        console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+        for (let ttlLeft = ttl; ttlLeft > 0; ttlLeft--) {
+            await delay(1000);
+            console.log(`${ttlLeft} seconds left...`);
+        }
+        console.log(`Done waiting for DNS to update.`);
     }
-    console.log(`Done waiting for DNS to update.`);
-
 }
 /** Keeps existing records */
 export async function addRecord(type: string, key: string, value: string, proxied?: "proxied") {
@@ -120,7 +125,8 @@ export async function addRecord(type: string, key: string, value: string, proxie
     let prevValues = await getRecordsRaw(type, key);
     // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
     //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
-    if (prevValues.some(x => x.content === value)) return;
+    let alreadyExisted = prevValues.some(x => x.content === value);
+    if (alreadyExisted && Date.now() - new Date(prevValues.find(x => x.content === value)!.modified_on).getTime() < DNS_REFRESH_STALE_AFTER) return;
     console.log(`Adding ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);
     const ttl = DNS_TTLSeconds[type as "A"] || 60;
     await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {
@@ -130,10 +136,12 @@ export async function addRecord(type: string, key: string, value: string, proxie
         ttl,
         proxied: proxied === "proxied",
     });
-    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
-    for (let ttlLeft = ttl; ttlLeft > 0; ttlLeft--) {
-        await delay(1000);
-        console.log(`${ttlLeft} seconds left...`);
+    if (!alreadyExisted) {
+        console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+        for (let ttlLeft = ttl; ttlLeft > 0; ttlLeft--) {
+            await delay(1000);
+            console.log(`${ttlLeft} seconds left...`);
+        }
+        console.log(`Done waiting for DNS to update.`);
     }
-    console.log(`Done waiting for DNS to update.`);
 }

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

@@ -22,6 +22,7 @@ import { sort } from "socket-function/src/misc";
 import { getPathStr2 } from "../path";
 import { PromiseObj } from "../promise";
 import { getTrueTimeOffset } from "socket-function/time/trueTimeShim";
+import { getGitRefLive } from "../4-deploy/git";
 setImmediate(() => {
     import("../diagnostics/MachineThreadInfo");
 });
@@ -136,6 +137,7 @@ export type NodeMetadata = {
     authoritySpec: AuthoritySpec;
     exposedControllers: string[];
     trueTimeOffset: number;
+    gitRef: string;
 };
 
 class NodeCapabilitiesControllerBase {
@@ -149,6 +151,7 @@ class NodeCapabilitiesControllerBase {
             authoritySpec: authorityLookup.getOurSpec(),
             exposedControllers: Array.from(SocketFunction.exposedClasses),
             trueTimeOffset: getTrueTimeOffset(),
+            gitRef: await getGitRefLive(),
         };
     }
 

package/src/-h-path-value-serialize/PathValueSerializer.ts

@@ -999,7 +999,9 @@ class PathValueSerializer {
         if (pathValue.isValueLazy) {
             let buffer = this.lazyValues.get(pathValue.value as {});
             if (!buffer) {
-                throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+                debugbreak(2);
+                debugger;
+                throw new Error(`(getPathValue) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
             }
             let newValue = recursiveFreeze(cbor.decode(buffer));
             if (!noMutate && !pathValue.isValueLazy) {
@@ -1024,10 +1026,12 @@ class PathValueSerializer {
         if (pathValue.isValueLazy) {
             let buffer = this.lazyValues.get(pathValue.value as {});
             if (!buffer) {
+                debugbreak(2);
+                debugger;
                 // NOTE: Did you pass a raw PathValue and then try to use PathValueSerializer with it?
                 //  - Instead you should pass a buffer serialized with pathValueSerializer.serialize and
                 //      deserialized with pathValueSerializer.deserialize.
-                throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+                throw new Error(`(getPathValueOrBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
             }
             return buffer;
         }
@@ -1037,7 +1041,11 @@ class PathValueSerializer {
     private getBuffer(pathValue: PathValue): Buffer {
         if (pathValue.isValueLazy) {
             let buffer = this.lazyValues.get(pathValue.value as {});
-            if (!buffer) throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+            if (!buffer) {
+                debugbreak(2);
+                debugger;
+                throw new Error(`(getBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+            }
             return buffer;
         }
         return cborEncoder().encode(pathValue.value);

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

@@ -421,6 +421,12 @@ export class PathRouter {
         return this.matchesAuthoritySpec(ourSpec, path);
     }
 
+    public static isSelfParentAuthority(path: string): boolean {
+        let nodes = PathRouter.getChildReadNodes(path, { onlyOwnNodes: true });
+        // NOTE: I think we can just do the node's length is greater than or equal to zero. However, the every check isn't gonna hurt...
+        return nodes.nodes.length > 0 && nodes.nodes.every(x => isOwnNodeId(x.nodeId));
+    }
+
 
 
     // NOTE: This might return overlapping specs. Presently, this is only used when we're loading our initial data, so it's fine. However, if we use this for another purpose in the future, it might cause problems. So we might need to implement a different function for that theoretical future purpose.

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

@@ -192,7 +192,7 @@ class PathWatcher {
         if (newPathsWatched.size > 0 || newParentsWatched.size > 0) {
             if (!this.remoteWatchCallback) throw new Error("remoteWatchCallback not set by the pathWatcher");
             let newRemotePaths = Array.from(newPathsWatched).filter(x => !PathRouter.isSelfAuthority(x));
-            let newRemoteParentPaths = Array.from(newParentsWatched).filter(x => !PathRouter.isSelfAuthority(x));
+            let newRemoteParentPaths = Array.from(newParentsWatched).filter(x => !PathRouter.isSelfParentAuthority(x));
             if (newRemotePaths.length > 0 || newRemoteParentPaths.length > 0) {
                 this.remoteWatchCallback({
                     paths: newRemotePaths,

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

@@ -667,13 +667,10 @@ class AuthorityPathValueStorage {
         }
 
         // Self authority check
-        {
-            let nodes = PathRouter.getChildReadNodes(originalPath, { onlyOwnNodes: true });
-            if (nodes.nodes.length > 0 && nodes.nodes.every(x => isOwnNodeId(x.nodeId))) {
-                // If we're the self authority of it, it's not going to change, so we can just cache it safely. 
-                this.parentsSynced.set(originalPath, true);
-                return true;
-            }
+        if (PathRouter.isSelfParentAuthority(originalPath)) {
+            // If we're the self authority of it, it's not going to change, so we can just cache it safely. 
+            this.parentsSynced.set(originalPath, true);
+            return true;
         }
 
         return false;

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

@@ -4,7 +4,7 @@ import { batchFunction, runInSerial, runInfinitePoll } from "socket-function/src
 import { cache } from "socket-function/src/caching";
 import { isNode, sort } from "socket-function/src/misc";
 import { measureFnc, measureBlock } from "socket-function/src/profiling/measure";
-import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
+import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PathValueController } from "../0-path-value-core/PathValueController";
 import { AuthoritySpec, PathRouter } from "../0-path-value-core/PathRouter";
 import { WatchConfig, authorityStorage } from "../0-path-value-core/pathValueCore";
@@ -164,6 +164,9 @@ export class RemoteWatcher {
         //  and the code calling this function isn't looking for that specific issue.
         return this.remoteWatchPaths.has(path) || !PathRouter.getReadyAuthority(path);
     }
+    public hasAnyDirectPathWatches(path: string) {
+        return this.remoteWatchPaths.has(path);
+    }
 
     /** @deprecated If you want to watch something, call pathWatcher.watchPath instead. */
     public watchLatest(config: WatchConfig & { debugName?: string }) {
@@ -687,8 +690,10 @@ registerGetSpecForChildPath(path => {
         let remoteWatchRange = remoteWatcher.getRemoteWatchParentRange(path);
         if (remoteWatchRange) return remoteWatchRange.authoritySpec;
 
-        // NOTE: This fall through usually means that we received a value before we started watching it, which is weird. That really shouldn't happen often. It'll probably break things. We will probably ignore this value thinking it has a different hash than it does.
-        console.warn(`We do not own a path, but also aren't watching it on a remote, but... receive the value? This is weird, and will probably break things (we will likely ignore this value / not trigger parent watches for it).`, { path });
+        if (!remoteWatcher.hasAnyDirectPathWatches(path)) {
+            // NOTE: This might mean that our Path Watcher and remote watcher are out of sync, which is a big problem and will break things. 
+            console.error(`We do not own a path, but also aren't watching it on a remote, but... receive the value? This is weird, and will probably break things (we will likely ignore this value / not trigger parent watches for it).`, { path });
+        }
     }
     return authorityLookup.getOurSpec();
 });

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

@@ -739,6 +739,9 @@ export class ClientWatcher {
         }
 
         if (!config.dryRun) {
+            for (let pv of pathValues) {
+                (globalThis as any).TEMP_TEST_LOG?.(pv.path, { kind: "setValues", writeTime, value: pv.value, locks: pv.locks });
+            }
             pathValueCommitter.commitValues(pathValues, config.noWritePrediction ? undefined : "predictWrites");
         }
 

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1491,7 +1491,7 @@ export class PathValueProxyWatcher {
                         }, 60000);
                     }
                     watcher.countSinceLastFullSync++;
-                    if (watcher.countSinceLastFullSync > 10) {
+                    if (watcher.countSinceLastFullSync > 100) {
                         console.warn(`Watcher ${watcher.debugName} has been unsynced for ${watcher.countSinceLastFullSync} times. This is fine, but maybe optimize it. Why is it cascading?`, { lastUnsyncedAccesses: watcher.lastUnsyncedAccesses, lastUnsyncedParentAccesses: watcher.lastUnsyncedParentAccesses }, watcher.options.watchFunction);
                     }
                     if (watcher.countSinceLastFullSync > 500) {

package/src/2-proxy/TransactionDelayer.ts

@@ -88,5 +88,5 @@ export function waitIfReceivedIncompleteTransaction(watcher: SyncWatcher) {
     // This really nicely both blocks it from finishing because of the waiting for the promise and also triggers it automatically when the delay finishes. HOWEVER, In practice, the promise should never be required to trigger it. It should trigger when we receive the missing parts of the transaction, which we will be, of course, watching as they're in the path values that we're accessing. The timeout is just in case something goes wrong and we incorrectly think we should receive the values, but we won't. That way, eventually, we do commit the value. 
     // ALSO! Plus the hash I think only stores like 48 bits. So the chance of collision is somewhat high, especially if we're accessing thousands of paths. So sometimes this will trigger even though we're not missing any part just because we had a collision between the path hashes. 
     proxyWatcher.triggerOnPromiseFinish(promise, { waitReason: "Missing transaction part" });
-    console.warn(`(NOT an error, convert this to a warning after we finish testing). Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
+    console.warn(`Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
 }

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

@@ -19,7 +19,8 @@ import { interceptCalls } from "../-0-hooks/hooks";
 import { createRoutingOverrideKey } from "../0-path-value-core/PathRouterRouteOverride";
 import { PathRouter } from "../0-path-value-core/PathRouter";
 import { getPathFromProxy } from "../2-proxy/pathValueProxy";
-import { getDomain } from "../config";
+import { getDomain, isPublic } from "../config";
+import { getFncFilter, isServer } from "../config2";
 
 // NOTE: We could deploy single functions, but... we will almost always be updating all functions at
 //      once, because keeping everything on the same git hash reduces a lot of potential bugs.
@@ -180,13 +181,17 @@ export function writeFunctionCall(config: {
         //  this is fine).
         callerIP: "127.0.0.1",
     };
-    if (!isNode()) {
-        // Get the "setfncfilter" querystring parameter
-        let url = new URL(window.location.href);
-        let setfncfilter = url.searchParams.get("setfncfilter");
-        if (setfncfilter) {
-            callSpec.filterable = parseFilterable(setfncfilter);
-        }
+    // NOTE: I don't know when this would ever really work. I guess to isolate function calls, but if we're running locally, isn't that easy? 
+    // if (!isNode()) {
+    //     // Get the "setfncfilter" querystring parameter
+    //     let url = new URL(window.location.href);
+    //     let setfncfilter = url.searchParams.get("setfncfilter");
+    //     if (setfncfilter) {
+    //         callSpec.filterable = parseFilterable(setfncfilter);
+    //     }
+    // }
+    if (isNode()) {
+        callSpec.filterable = getFncFilter();
     }
 
     if (curInterceptor) {

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

@@ -385,6 +385,8 @@ export class PathFunctionRunner {
                         }
 
                         if (PathFunctionRunner.DEBUG_CALLS) {
+                            // NOTE: If this start, it means that the filter didn't match, which either means it was a dev function and so not relevant for us, or we are dev and it's a production function, so not relevant for us.
+                            //  - The filter is set by fncfilter when running serverside, or, clientside, by fncfilter set on the command line of the querysub server.
                             console.log(`QUEUING ${getDebugName(callData, functionSpec, true)}`);
                             let resultsPath = getProxyPath(() => moduleData.Results[callId]);
                             let history = authorityStorage.getValuePlusHistory(resultsPath);

package/src/4-querysub/Querysub.ts

@@ -1333,7 +1333,6 @@ setImmediate(async () => {
     // Import, so it registers addStatPeriodic
     await import("../5-diagnostics/nodeMetadata");
     await import("../diagnostics/pathAuditer");
-    await import("../diagnostics/NodeConnectionsPage");
 });
 
 setImmediate(async () => {

package/src/4-querysub/QuerysubController.ts

@@ -27,7 +27,7 @@ import { CallerContextBase } from "socket-function/SocketFunctionTypes";
 import { isTrustedByNode } from "../-d-trust/NetworkTrust2";
 import { Querysub, id } from "./Querysub";
 import { isDefined } from "../misc";
-import { isClient, isServer } from "../config2";
+import { getFncFilter, isClient, isServer } from "../config2";
 import { PromiseObj } from "../promise";
 import { LoggingClient } from "../0-path-value-core/LoggingClient";
 import * as prediction from "./querysubPrediction";
@@ -42,12 +42,6 @@ import { PathRouter } from "../0-path-value-core/PathRouter";
 import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
 import { PathValueArchives } from "../0-path-value-core/pathValueArchives";
 
-let yargObj = isNodeTrue() && yargs(process.argv)
-    .option("fncfilter", { type: "string", default: "", desc: `Sets the filterable state for function calls, causing them to target specific FunctionRunners. If no FunctionRunner matches, all functions will fail to run. For example: "devtestserver" will match a FunctionRunner that uses the "devtestserver" filter. Merges with the existing filterable state if a client sets it explicitly.` })
-    .argv
-    ;
-
-const getFncFilter = lazy(() => parseFilterable(yargObj.fncfilter));
 
 export { Querysub, id };
 

package/src/config.ts

@@ -31,8 +31,14 @@ let yargObj = parseArgsFactory()
     })
     .option("logbackblaze", { type: "boolean", desc: "Log all backblaze activity to disk." })
     .option("slowdown", { type: "number", desc: "Delay all input data values by this amount of time, pretending like we didn't even receive it until this time is up." })
+    .option("fncfilter", { type: "string", default: "", desc: `Sets the filterable state for function calls, causing them to target specific FunctionRunners. If no FunctionRunner matches, all functions will fail to run. For example: "devtestserver" will match a FunctionRunner that uses the "devtestserver" filter. Merges with the existing filterable state if a client sets it explicitly.` })
     .argv
     ;
+
+export function getRawFncFilter() {
+    return yargObj.fncfilter;
+}
+
 type QuerysubConfig = {
     domain?: string;
     emaildomain?: string;

package/src/config2.ts

@@ -1,10 +1,12 @@
 import { deepCloneJSON, isNode } from "socket-function/src/misc";
 import { hasArchivesPermissions } from "./-a-archives/archives";
-import { baseIsClient, getDomain } from "./config";
+import { baseIsClient, getDomain, getRawFncFilter } from "./config";
 import { JSONLACKS } from "socket-function/src/JSONLACKS/JSONLACKS";
 import { rootPathStr, prependToPathStr, getPathDepth } from "./path";
 import fs from "fs";
 import { AuthoritySpec } from "./0-path-value-core/PathRouter";
+import { parseFilterable } from "./misc/filterable";
+import { lazy } from "socket-function/src/caching";
 
 let isInCall = false;
 export function isClient() {
@@ -21,3 +23,7 @@ export function isServer() {
 }
 
 // NOTE: getOurAuthorities moved to PathRouterHashOverrides, and renamed to getOurAuthoritySpec
+
+
+
+export const getFncFilter = lazy(() => parseFilterable(getRawFncFilter() || ""));

package/src/deployManager/components/MachinePicker.tsx

@@ -0,0 +1,40 @@
+import preact from "preact";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../../4-dom/qreact";
+import { sort } from "socket-function/src/misc";
+import { isDefined } from "../../misc";
+import { formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+import { InputPicker } from "../../library-components/InputPicker";
+import { MachineServiceController } from "../machineSchema";
+
+module.hotreload = true;
+
+export class MachinePicker extends qreact.Component<{
+    label?: preact.ComponentChild;
+    picked: string[];
+    addPicked: (machineId: string) => void;
+    removePicked: (machineId: string) => void;
+    singleOption?: boolean;
+    fillWidth?: boolean;
+}> {
+    render() {
+        let controller = MachineServiceController(SocketFunction.browserNodeId());
+        let machines = (controller.getMachineList() || []).map(x => controller.getMachineInfo(x)).filter(isDefined);
+        sort(machines, x => -x.heartbeat);
+
+        let options = machines.map(machineObj => ({
+            value: machineObj.machineId,
+            label: `${machineObj.machineId} ${machineObj.info["getExternalIP"]} (${Object.keys(machineObj.services || {}).length} services, last heartbeat ${formatVeryNiceDateTime(machineObj.heartbeat)})`,
+        }));
+
+        return <InputPicker<string>
+            label={this.props.label}
+            picked={this.props.picked}
+            options={options}
+            addPicked={this.props.addPicked}
+            removePicked={this.props.removePicked}
+            singleOption={this.props.singleOption}
+            fillWidth={this.props.fillWidth}
+        />;
+    }
+}

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -7,6 +7,7 @@ import { Querysub } from "../../4-querysub/QuerysubController";
 import { currentViewParam, selectedServiceIdParam, selectedMachineIdParam } from "../urlParams";
 import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { InputPicker } from "../../library-components/InputPicker";
+import { MachinePicker } from "./MachinePicker";
 import { deepCloneJSON, nextId, sort } from "socket-function/src/misc";
 import { InputLabel } from "../../library-components/InputLabel";
 import { Button } from "../../library-components/Button";
@@ -291,13 +292,9 @@ export class ServiceDetailPage extends qreact.Component {
                 />
             </div>
 
-            <InputPicker
+            <MachinePicker
                 label="Machines"
                 picked={config.machineIds}
-                options={machines.map(machineObj => ({
-                    value: machineObj.machineId,
-                    label: `${machineObj.machineId} ${machineObj.info["getExternalIP"]} (${Object.keys(machineObj.services || {}).length} services, last heartbeat ${formatVeryNiceDateTime(machineObj.heartbeat)})`
-                }))}
                 addPicked={machineId => {
                     configT.machineIds.push(machineId);
                     this.updateUnsavedChanges(configT);

package/src/deployManager/components/ServicesListPage.tsx

@@ -13,6 +13,7 @@ import { isPublic } from "../../config";
 import { UpdateButtons, UpdateServiceButtons } from "./deployButtons";
 import { isDefined } from "../../misc";
 import { formatDateJSX } from "../../misc/formatJSX";
+import { Tools } from "./Tools";
 
 module.hotreload = true;
 
@@ -74,6 +75,7 @@ export class ServicesListPage extends qreact.Component {
                 </button>
                 <UpdateButtons services={services.map(x => x[1]).filter(isDefined)} />
             </div>
+            <Tools />
             <div className={css.vbox(8)}>
                 {services.map(([serviceId, config]) => {
                     if (!config) return <div key={serviceId}>Config is broken? Missing value for service? Is the file corrupted?</div>;

package/src/deployManager/components/Tools.tsx

@@ -0,0 +1,165 @@
+import preact from "preact";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../../4-dom/qreact";
+import { css } from "typesafecss";
+import { t } from "../../2-proxy/schema2";
+import { Querysub } from "../../4-querysub/QuerysubController";
+import { MachineServiceController, ServiceConfig } from "../machineSchema";
+import { MachinePicker } from "./MachinePicker";
+import { isDefined } from "../../misc";
+
+module.hotreload = true;
+
+type ToolEntry = {
+    key: string;
+    title: string;
+    render: () => preact.ComponentChild;
+};
+
+export class Tools extends qreact.Component {
+    state = t.state({
+        expanded: t.atomic<boolean>(false),
+        expandedTools: t.lookup(t.boolean),
+    });
+
+    render() {
+        let tools: ToolEntry[] = [
+            {
+                key: "rename-machine",
+                title: "Rename Machine",
+                render: () => <RenameMachine />,
+            },
+        ];
+
+        return <div className={css.vbox(8)}>
+            <div
+                className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 0, 95)}
+                onClick={() => {
+                    this.state.expanded = !this.state.expanded;
+                }}
+            >
+                <span className={css.boldStyle}>{this.state.expanded ? "▼" : "▶"} Tools</span>
+            </div>
+            {this.state.expanded && <div className={css.vbox(6).paddingLeft(12)}>
+                {tools.map(tool => {
+                    let isExpanded = !!this.state.expandedTools[tool.key];
+                    return <div className={css.vbox(6)} key={tool.key}>
+                        <div
+                            className={css.pad2(10, 6).button.bord2(0, 0, 20).hsl(0, 0, 98)}
+                            onClick={() => {
+                                if (this.state.expandedTools[tool.key]) {
+                                    delete this.state.expandedTools[tool.key];
+                                } else {
+                                    this.state.expandedTools[tool.key] = true;
+                                }
+                            }}
+                        >
+                            <span>{isExpanded ? "▼" : "▶"} {tool.title}</span>
+                        </div>
+                        {isExpanded && <div className={css.pad2(10).bord2(0, 0, 20).hsl(0, 0, 100)}>
+                            {tool.render()}
+                        </div>}
+                    </div>;
+                })}
+            </div>}
+        </div>;
+    }
+}
+
+class RenameMachine extends qreact.Component {
+    state = t.state({
+        fromMachineId: t.string,
+        toMachineId: t.string,
+        isRunning: t.atomic<boolean>(false),
+        resultMessage: t.string,
+        errorMessage: t.string,
+    });
+
+    render() {
+        let controller = MachineServiceController(SocketFunction.browserNodeId());
+
+        let { fromMachineId, toMachineId } = this.state;
+        let canRun = !!fromMachineId && !!toMachineId && fromMachineId !== toMachineId && !this.state.isRunning;
+
+        return <div className={css.vbox(10)}>
+            <div className={css.colorhsl(0, 0, 40)}>
+                Rewrites every service config: any occurrence of "From" in its <code>machineIds</code> becomes "To".
+            </div>
+            <MachinePicker
+                label="From"
+                singleOption
+                picked={fromMachineId ? [fromMachineId] : []}
+                addPicked={(value) => { this.state.fromMachineId = value; }}
+                removePicked={() => { this.state.fromMachineId = ""; }}
+            />
+            <MachinePicker
+                label="To"
+                singleOption
+                picked={toMachineId ? [toMachineId] : []}
+                addPicked={(value) => { this.state.toMachineId = value; }}
+                removePicked={() => { this.state.toMachineId = ""; }}
+            />
+            <div className={css.hbox(8)}>
+                <button
+                    className={css.pad2(12, 8).button.bord2(0, 0, 20)
+                        + (canRun ? css.hsl(0, 0, 100) : css.hsl(0, 0, 85).colorhsl(0, 0, 50))}
+                    disabled={!canRun}
+                    onClick={() => {
+                        if (!canRun) return;
+                        let from = fromMachineId;
+                        let to = toMachineId;
+                        let confirmed = confirm(`Rename machine "${from}" → "${to}" across all service configs?\n\nThis updates every ServiceConfig that references "${from}".`);
+                        if (!confirmed) return;
+
+                        Querysub.commit(() => {
+                            this.state.isRunning = true;
+                            this.state.resultMessage = "";
+                            this.state.errorMessage = "";
+                        });
+
+                        Querysub.onCommitFinished(async () => {
+                            try {
+                                let serviceIds = await controller.getServiceList.promise();
+                                let configs = await Promise.all(
+                                    serviceIds.map(id => controller.getServiceConfig.promise(id))
+                                );
+                                let toUpdate: ServiceConfig[] = [];
+                                for (let config of configs.filter(isDefined)) {
+                                    if (!config.machineIds.includes(from)) continue;
+                                    let newMachineIds = config.machineIds.map(m => m === from ? to : m);
+                                    toUpdate.push({
+                                        ...config,
+                                        machineIds: newMachineIds,
+                                    });
+                                }
+                                if (toUpdate.length === 0) {
+                                    Querysub.commit(() => {
+                                        this.state.resultMessage = `No service configs referenced "${from}".`;
+                                    });
+                                } else {
+                                    await controller.setServiceConfigs.promise(toUpdate);
+                                    Querysub.commit(() => {
+                                        this.state.resultMessage = `Updated ${toUpdate.length} service config(s).`;
+                                    });
+                                }
+                            } catch (err) {
+                                console.error(`RenameMachine failed:`, (err as Error).stack ?? err);
+                                Querysub.commit(() => {
+                                    this.state.errorMessage = (err as Error).stack ?? String(err);
+                                });
+                            } finally {
+                                Querysub.commit(() => {
+                                    this.state.isRunning = false;
+                                });
+                            }
+                        });
+                    }}
+                >
+                    {this.state.isRunning ? "Renaming..." : "Rename"}
+                </button>
+            </div>
+            {this.state.resultMessage && <div className={css.colorhsl(120, 50, 30)}>{this.state.resultMessage}</div>}
+            {this.state.errorMessage && <pre className={css.colorhsl(0, 60, 40).whiteSpace("pre-wrap")}>{this.state.errorMessage}</pre>}
+        </div>;
+    }
+}