querysub 0.259.0 → 0.261.0

package/.cursorrules

@@ -49,6 +49,8 @@ Don't use switch statements. Use if statements instead.
 
 Don't use ! when accessing a value from a map. Use the get / if undefined initialize and set, and then use style. It's faster, and more type safe.
 
+NEVER use the non-null assertion operator. Null check correctly, using const if required to preserve the assertion.
+
 Sort with this function, which takes a single function to map each object to a sortable value
     import { sort } from "socket-function/src/misc";
     export function sort<T>(arr: T[], sortKey: (obj: T) => unknown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.259.0",
+  "version": "0.261.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/-e-certs/EdgeCertController.ts

@@ -31,7 +31,7 @@ import { shutdown } from "../diagnostics/periodic";
 
 let publicPort = -1;
 
-const getHostedIP = lazy(async () => {
+export const getHostedIP = lazy(async () => {
     if (!isPublic()) {
         return "127.0.0.1";
     }

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

@@ -1,6 +1,6 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { getArchives } from "../-a-archives/archives";
-import { getDomain, isDevDebugbreak, isNoNetwork } from "../config";
+import { getDomain, isDevDebugbreak, isNoNetwork, isPublic } from "../config";
 import { measureBlock } from "socket-function/src/profiling/measure";
 import { isNode, sha256Hash, throttleFunction, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { errorToUndefinedSilent, ignoreErrors, logErrors, timeoutToUndefinedSilent } from "../errors";
@@ -178,8 +178,8 @@ function setNodeIds(nodeIds: string[]) {
     nodeIds = nodeIds.filter(x => x !== SPECIAL_NODE_ID_FOR_UNMOUNTED_NODE);
 
     diskLog("setNodeIds", { nodeIds });
-    // Also try all localhost ports, if we are in dev mode
-    if (isNode() && isDevDebugbreak()) {
+    // Also try all localhost ports, if we are developing and not in public mode
+    if (isNode() && !isPublic() && isDevDebugbreak()) {
         let ports = new Set(nodeIds.map(nodeId => decodeNodeId(nodeId)?.port).filter(isDefined));
         for (let port of ports) {
             let localNodeId = getNodeId("127-0-0-1." + getDomain(), port);

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

@@ -20,7 +20,6 @@ import { interceptCalls } from "../-0-hooks/hooks";
 // 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.
 export async function replaceFunctions(config: {
-    domainName: string;
     functions: FunctionSpec[];
 }) {
     await proxyWatcher.commitFunction({
@@ -30,12 +29,12 @@ export async function replaceFunctions(config: {
                 return `${func.DomainName}:${func.FilePath}:${func.ModuleId}:${func.FunctionId}`;
             }
 
-            let { domainName, functions } = config;
-            for (let fnc of functions) {
-                if (fnc.DomainName !== domainName) {
-                    throw new Error(`Tried to deploy function ${fnc.FunctionId} is not in domain ${domainName}, was in ${fnc.DomainName}`);
-                }
+            let { functions } = config;
+            let domainsNames = new Set(functions.map(x => x.DomainName));
+            if (domainsNames.size !== 1) {
+                throw new Error(`Tried to deploy functions with multiple domains, ${JSON.stringify(domainsNames)}`);
             }
+            let domainName = Array.from(domainsNames)[0];
 
             let base = functionSchema()[domainName].PathFunctionRunner;
             let previousFunctions = Object.values(base).flatMap(x => Object.values(x.Sources)).filter(isDefined);

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

@@ -24,6 +24,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { getDomain, isLocal } from "../config";
 import { getGitRefSync, getGitURLSync } from "../4-deploy/git";
+import { DeployProgress } from "../4-deploy/deployFunctions";
 
 export const functionSchema = rawSchema<{
     [domainName: string]: {
@@ -683,12 +684,18 @@ export class PathFunctionRunner {
     }
 }
 
-export async function preloadFunctions(specs: FunctionSpec[]) {
+export async function preloadFunctions(specs: FunctionSpec[], progress?: DeployProgress) {
+    progress?.({ section: "Finding FunctionPreloadControllers", progress: 0 });
     let nodeIds = await getControllerNodeIdList(FunctionPreloadController);
-    await Promise.allSettled(nodeIds.map(async nodeId => {
-        let controller = FunctionPreloadController.nodes[nodeId.nodeId];
+    progress?.({ section: "Finding FunctionPreloadControllers", progress: 1 });
+    await Promise.allSettled(nodeIds.map(async nodeObj => {
+        let nodeId = nodeObj.nodeId;
+        let controller = FunctionPreloadController.nodes[nodeId];
+        let section = `${nodeObj.entryPoint}:${nodeId}|Preloading Functions`;
+        progress?.({ section, progress: 0 });
         console.log(blue(`Preloading functions on ${String(nodeId)}`));
         await errorToUndefined(controller.preloadFunctions(specs));
+        progress?.({ section, progress: 1 });
         console.log(blue(`Finished preloading functions on ${String(nodeId)}`));
     }));
 }

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

@@ -19,10 +19,10 @@ import { ClientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { PermissionsCheck } from "../4-querysub/permissions";
 import { timeInMinute } from "socket-function/src/misc";
 import { getDomain, isLocal, isPublic } from "../config";
-import { publishMachineARecords } from "../-e-certs/EdgeCertController";
 import { green, magenta } from "socket-function/src/formatting/logColors";
 import { parseFilterSelector } from "../misc/filterable";
 import path from "path";
+import { Querysub } from "../4-querysub/QuerysubController";
 
 async function main() {
     Error.stackTraceLimit = 20;
@@ -37,9 +37,7 @@ async function main() {
     PathFunctionRunner.DEBUG_CALLS = true;
     // debugCoreMode();
 
-    let keyPair = await getThreadKeyCert();
-    await SocketFunction.mount({ port: 0, ...keyPair, public: isPublic() });
-    await publishMachineARecords();
+    await Querysub.hostService("PathFunctionRunnerMain");
 
     // Use a fairly high stick time (the default is 10s), because having wait to sync data is very slow,
     //  and the function runner SHOULD have more memory than the clients, and much faster network speeds

package/src/4-deploy/deployFunctions.ts

@@ -0,0 +1,82 @@
+import { magenta } from "socket-function/src/formatting/logColors";
+import { FunctionSpec, preloadFunctions } from "../3-path-functions/PathFunctionRunner";
+import { Querysub } from "../4-querysub/QuerysubController";
+import { errorify } from "../errors";
+import { runPromise } from "../functional/runCommand";
+import path from "path";
+import { preloadUI } from "./edgeNodes";
+import { proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
+import { replaceFunctions } from "../3-path-functions/PathFunctionHelpers";
+import { setLiveDeployedHash } from "./deploySchema";
+
+export async function deployGetFunctions(): Promise<FunctionSpec[]> {
+    let innerPath = path.resolve(__dirname + "/deployGetFunctionsInner.ts").replaceAll("\\", "/");
+    let result = await runPromise(`yarn typenode ${innerPath}`);
+    let functionSpecs: FunctionSpec[] = [];
+    for (let line of result.split("\n")) {
+        if (line.startsWith("ERROR:")) {
+            throw errorify(line.slice("ERROR:".length));
+        }
+        if (line.startsWith("FUNCTION_SPEC:")) {
+            let spec = JSON.parse(line.slice("FUNCTION_SPEC:".length));
+            functionSpecs.push(spec);
+        }
+    }
+    return functionSpecs;
+}
+
+//todonext;
+// Ugh... some kind of throttling? Nah...
+// So... progress sections, just... start and stop?
+export type DeployProgress = {
+    (config: { section: string; progress: number; }): void;
+};
+
+export async function deployFunctions(config: {
+    functionSpecs: FunctionSpec[];
+    notifyRefreshDelay: number;
+    deployOnlyCode?: boolean;
+    deployOnlyUI?: boolean;
+    progress?: DeployProgress;
+}) {
+    const { functionSpecs, notifyRefreshDelay, deployOnlyCode, deployOnlyUI } = config;
+    let gitRefs = new Set(functionSpecs.map(x => x.gitRef));
+    if (gitRefs.size !== 1) {
+        throw new Error(`Tried to deploy functions with multiple git refs, ${JSON.stringify(gitRefs)}`);
+    }
+    let gitRef = Array.from(gitRefs)[0];
+    const currentFunctions = functionSpecs;
+
+    console.log();
+    console.log();
+    console.log(magenta(`Preloading ${currentFunctions.length} functions & UI`));
+    await Promise.all([
+        preloadFunctions(currentFunctions, config.progress),
+        preloadUI(gitRef, config.progress),
+    ]);
+
+    console.log();
+    console.log();
+    console.log(magenta(`Deploying ${currentFunctions.length} functions`));
+
+    let refreshThresholdTime = Date.now() + notifyRefreshDelay;
+
+    config.progress?.({ section: "Deploying Functions", progress: 0 });
+    await proxyWatcher.commitFunction({
+        debugName: "setLiveDeployedHash",
+        inlineNestedWatchers: true,
+        watchFunction: () => {
+            if (deployOnlyUI) {
+                void setLiveDeployedHash({ hash: gitRef, refreshThresholdTime, });
+            } else if (deployOnlyCode) {
+                void replaceFunctions({ functions: currentFunctions, });
+            } else {
+                void replaceFunctions({ functions: currentFunctions, });
+                void setLiveDeployedHash({ hash: gitRef, refreshThresholdTime, });
+            }
+        },
+    });
+    config.progress?.({ section: "Deploying Functions", progress: 1 });
+
+    console.log(magenta(`FINISHED DEPLOY (${gitRef})`));
+}

package/src/4-deploy/deployGetFunctionsInner.ts

@@ -0,0 +1,94 @@
+import path from "path";
+import { deployBlock } from "./deployBlock";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getThreadKeyCert } from "../-a-auth/certs";
+import { getDomain, isPublic } from "../config";
+import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
+import { getSchemaObject, getModuleRelativePath, PERMISSIONS_FUNCTION_ID, getExportPath } from "../3-path-functions/syncSchema";
+import { getPathStr2 } from "../path";
+import { FunctionSpec } from "../3-path-functions/PathFunctionRunner";
+import fs from "fs";
+import { getGitRefLive, getGitURLLive } from "./git";
+
+async function main() {
+    let domainName = getDomain();
+    if (!domainName) {
+        throw new Error(`No domain found, set in querysub.json { domain: "example.com" }, or in --domain "example.com"`);
+    }
+
+    await deployBlock();
+
+    // Mount, so we can write directly to the database
+    await SocketFunction.mount({ port: 0, ...await getThreadKeyCert(), public: isPublic() });
+
+    let folderRoot = path.resolve(".").replaceAll("\\", "/");
+    const deployPath = path.resolve("./deploy.ts");
+    await import(deployPath);
+
+    const querysubRoot = path.resolve(__dirname + "/../").replaceAll("\\", "/");
+
+    let gitDir = folderRoot;
+    if (!fs.existsSync(gitDir + "/.git")) {
+        throw new Error(`No .git folder found at ${JSON.stringify(gitDir + "/.git")}`);
+    }
+    let gitURL = await getGitURLLive(gitDir);
+    if (!gitURL) {
+        throw new Error(`Git repo has no remote url, at ${JSON.stringify(gitDir + "/.git")}`);
+    }
+    let gitRef = await getGitRefLive(gitDir);
+
+    let usedModules = new Map<string, string>();
+    for (let module of Object.values(require.cache)) {
+        if (!module) continue;
+
+        // NOTE: We don't want dependencies to deploy schemas. This would result in using an
+        //  API also deploying it.
+        //  - Also, this add more security, by preventing 3rd party libraries from secretly adding apis
+        //      (maybe even just innocently, for diagnostics), which might have vulnerabilities.
+        let isAllowedToDeploy = (
+            !module.filename.includes("node_modules")
+            && module.filename.startsWith(folderRoot)
+        );
+
+        // We DO allow querysub to deploy, so we can deploy diagnostic functions, such as
+        //  for the managment interfaces. It only works if the user opts in (by calling
+        //  registerManagementPages2), so it is actually quite safe to do this.
+        if (module.filename.startsWith(querysubRoot)) {
+            isAllowedToDeploy = true;
+        }
+
+        if (!isAllowedToDeploy) continue;
+        let schema = getSchemaObject(module);
+        if (!schema) continue;
+        // If it's local, we don't need to deploy it.
+        //  (And shouldn't?, as we don't want to run local functions by request?)
+        if (schema.domainName === LOCAL_DOMAIN) continue;
+
+        let filePath = getModuleRelativePath(module);
+
+        let moduleId = getPathStr2(domainName, filePath);
+        let otherUsed = usedModules.get(moduleId);
+        if (otherUsed) {
+            throw new Error(`Overlapping module ids for ${domainName}.${filePath}, at ${otherUsed} and ${filePath}`);
+        }
+        usedModules.set(moduleId, filePath);
+
+        const functionIds = Object.keys(schema.rawFunctions);
+        functionIds.push(PERMISSIONS_FUNCTION_ID);
+        for (let functionId of functionIds) {
+            const exportPathStr = getExportPath(functionId);
+            let spec: FunctionSpec = {
+                DomainName: domainName,
+                ModuleId: schema.moduleId,
+                FilePath: filePath,
+                FunctionId: functionId,
+                exportPathStr,
+                gitURL,
+                gitRef,
+            };
+            console.log(`FUNCTION_SPEC:${JSON.stringify(spec)}`);
+        }
+    }
+}
+
+main().catch(e => console.error("ERROR:" + String(e?.stack || e).replaceAll("\n", "\\n"))).finally(() => process.exit(0));

package/src/4-deploy/deployMain.ts

@@ -25,6 +25,8 @@ import { preloadUI } from "./edgeNodes";
 import { shutdown } from "../diagnostics/periodic";
 import { delay } from "socket-function/src/batching";
 import { waitForImportBlockers } from "../3-path-functions/pathFunctionLoader";
+import { deployFunctions, deployGetFunctions } from "./deployFunctions";
+import { Querysub } from "../4-querysub/QuerysubController";
 
 let yargObj = yargs(process.argv)
     .option("deployonlycode", { type: "boolean", desc: "Only deploy code, not ui" })
@@ -41,88 +43,10 @@ export async function deployMain() {
     //quietCoreMode();
     //ClientWatcher.DEBUG_READS = true;
     //ClientWatcher.DEBUG_WRITES = true;
-    let domainName = getDomain();
-    if (!domainName) {
-        throw new Error(`No domain found, set in querysub.json { domain: "example.com" }, or in --domain "example.com"`);
-    }
-    await deployBlock();
-
-    // Mount, so we can write directly to the database
-    await SocketFunction.mount({ port: 0, ...await getThreadKeyCert(), public: isPublic() });
-
-    let folderRoot = path.resolve(".").replaceAll("\\", "/");
-    const deployPath = path.resolve("./deploy.ts");
-    require(deployPath);
-
-    // Wait for Promise.resolve imports to import
-    await waitForImportBlockers();
-
-    const srcRoot = path.resolve(__dirname + "/../").replaceAll("\\", "/");
-
-    let currentFunctions: FunctionSpec[] = [];
-
-    let gitDir = folderRoot;
-    if (!fs.existsSync(gitDir + "/.git")) {
-        throw new Error(`No .git folder found at ${JSON.stringify(gitDir + "/.git")}`);
-    }
-    let gitURL = await getGitURLLive(gitDir);
-    if (!gitURL) {
-        throw new Error(`Git repo has no remote url, at ${JSON.stringify(gitDir + "/.git")}`);
-    }
-    let gitRef = await getGitRefLive(gitDir);
-
-    let usedModules = new Map<string, string>();
 
-    for (let module of Object.values(require.cache)) {
-        if (!module) continue;
+    await Querysub.hostService("deployMain");
 
-        // NOTE: We don't want dependencies to deploy schemas. This would result in using an
-        //  API also deploying it.
-        //  - Also, this add more security, by preventing 3rd party libraries from adding apis
-        //      (maybe even just innocent, for diagnostics), which might have vulnerabilities.
-        let isAllowedToDeploy = (
-            !module.filename.includes("node_modules")
-            && module.filename.startsWith(folderRoot)
-        );
-
-        // We DO allow shard to deploy, so we can deploy diagnostic functions, such as
-        //  for the managment interfaces. It only works if the user opts in (by calling
-        //  registerManagementPages2), so it is actually quite safe to do this.
-        if (module.filename.startsWith(srcRoot)) {
-            isAllowedToDeploy = true;
-        }
-
-        if (!isAllowedToDeploy) continue;
-        let schema = getSchemaObject(module);
-        if (!schema) continue;
-        // If it's local, we don't need to deploy it.
-        //  (And shouldn't?, as we don't want to run local functions by request?)
-        if (schema.domainName === LOCAL_DOMAIN) continue;
-
-        let filePath = getModuleRelativePath(module);
-
-        let moduleId = getPathStr2(domainName, filePath);
-        let otherUsed = usedModules.get(moduleId);
-        if (otherUsed) {
-            throw new Error(`Overlapping module ids for ${domainName}.${filePath}, at ${otherUsed} and ${filePath}`);
-        }
-        usedModules.set(moduleId, filePath);
-
-        const functionIds = Object.keys(schema.rawFunctions);
-        functionIds.push(PERMISSIONS_FUNCTION_ID);
-        for (let functionId of functionIds) {
-            const exportPathStr = getExportPath(functionId);
-            currentFunctions.push({
-                DomainName: domainName,
-                ModuleId: schema.moduleId,
-                FilePath: filePath,
-                FunctionId: functionId,
-                exportPathStr,
-                gitURL,
-                gitRef,
-            });
-        }
-    }
+    const currentFunctions = await deployGetFunctions();
     for (let fnc of currentFunctions) {
         console.log(blue(`${fnc.DomainName}.${fnc.ModuleId}.${fnc.FunctionId}`));
     }
@@ -131,37 +55,13 @@ export async function deployMain() {
         return;
     }
 
-    console.log();
-    console.log();
-    console.log(magenta(`Preloading ${currentFunctions.length} functions & UI`));
-    await Promise.all([
-        preloadFunctions(currentFunctions),
-        preloadUI(gitRef),
-    ]);
-
-    console.log();
-    console.log();
-    console.log(magenta(`Deploying ${currentFunctions.length} functions`));
-
-    let refreshThresholdTime = Date.now() + yargObj.notifyrefreshdelay;
-
-    await proxyWatcher.commitFunction({
-        debugName: "setLiveDeployedHash",
-        inlineNestedWatchers: true,
-        watchFunction: () => {
-            if (yargObj.deployonlycode) {
-                void setLiveDeployedHash({ hash: gitRef, refreshThresholdTime, });
-            } else if (yargObj.deployonlyui) {
-                void replaceFunctions({ domainName, functions: currentFunctions, });
-            } else {
-                void replaceFunctions({ domainName, functions: currentFunctions, });
-                void setLiveDeployedHash({ hash: gitRef, refreshThresholdTime, });
-            }
-        },
+    await deployFunctions({
+        functionSpecs: currentFunctions,
+        notifyRefreshDelay: yargObj.notifyrefreshdelay,
+        deployOnlyCode: yargObj.deployonlycode,
+        deployOnlyUI: yargObj.deployonlyui,
     });
 
-    console.log(magenta(`FINISHED DEPLOY (${gitRef})`));
-
     await shutdown();
 }
 

package/src/4-deploy/edgeBootstrap.ts

@@ -429,6 +429,9 @@ async function edgeNodeFunction(config: {
         let host = edgeNodeConfig.host;
         if (!host.endsWith("/")) host += "/";
         for (let entryPath of edgeNodeConfig.entryPaths) {
+            if (entryPath.startsWith("/")) {
+                entryPath = entryPath.slice("/".length);
+            }
             await require("https://" + host + entryPath);
         }
     }

package/src/4-deploy/edgeClientWatcher.tsx

@@ -24,6 +24,9 @@ export function startEdgeNotifier() {
         if (liveHash === lastHashServer) return;
         let refreshThresholdTime = atomicObjectRead(deploySchema()[getDomain()].deploy.live.refreshThresholdTime) || timeInMinute;
         lastHashServer = liveHash;
+        if (!curHash) {
+            curHash = liveHash;
+        }
         void notifyClients(liveHash, refreshThresholdTime);
     });
 }
@@ -52,6 +55,7 @@ function onLiveHashChange(liveHash: string, refreshThresholdTime: number) {
     let prevHash = curHash;
     let notifyIntervals = [0, 0.1, 0.5, 1];
     console.log(blue(`Client liveHash changed ${liveHash}, prev hash: ${prevHash}`));
+    // If we are replacing an already existing notification, don't show immediately
     let skipFirst = false;
     if (currentNotification) {
         currentNotification.close();

package/src/4-deploy/edgeNodes.ts

@@ -25,6 +25,7 @@ import { Querysub } from "../4-querysub/QuerysubController";
 import { onEdgeNodesChanged } from "./edgeBootstrap";
 import { startEdgeNotifier } from "./edgeClientWatcher";
 import { getGitRefLive, getGitURLLive } from "./git";
+import { DeployProgress } from "./deployFunctions";
 
 const UPDATE_POLL_INTERVAL = timeInMinute * 15;
 const DEAD_NODE_COUNT_THRESHOLD = 15;
@@ -259,12 +260,17 @@ async function updateEdgeNodesFile() {
     await edgeNodeStorage.set(edgeNodeIndexFile, Buffer.from(JSON.stringify(newEdgeNodeIndex)));
 }
 
-export async function preloadUI(hash: string) {
+export async function preloadUI(hash: string, progress?: DeployProgress) {
+    progress?.({ section: "Finding EdgeNodeControllers", progress: 0 });
     let nodeIds = await getControllerNodeIdList(EdgeNodeController);
+    progress?.({ section: "Finding EdgeNodeControllers", progress: 1 });
     await Promise.allSettled(nodeIds.map(async nodeId => {
         let controller = EdgeNodeController.nodes[nodeId.nodeId];
+        let section = `${nodeId.entryPoint}:${nodeId.nodeId}|Preloading UI`;
+        progress?.({ section, progress: 0 });
         console.log(blue(`Preloading UI on ${String(nodeId)}, hash: ${hash}`));
         await errorToUndefined(controller.preloadUI({ hash }));
+        progress?.({ section, progress: 1 });
         console.log(blue(`Finished preloading UI on ${String(nodeId)}`));
     }));
 }

package/src/4-querysub/Querysub.ts

@@ -6,14 +6,14 @@ import "../inject";
 import { shimDateNow } from "socket-function/time/trueTimeShim";
 shimDateNow();
 
-import { isNode, isNodeTrue, timeInMinute } from "socket-function/src/misc";
+import { isNode, isNodeTrue, timeInMinute, timeInSecond, timeoutToUndefined } from "socket-function/src/misc";
 
 import { SocketFunction } from "socket-function/SocketFunction";
 import { isHotReloading, watchFilesAndTriggerHotReloading } from "socket-function/hot/HotReloadController";
 import { RequireController, setRequireBootRequire } from "socket-function/require/RequireController";
 import { cache, cacheLimited, lazy } from "socket-function/src/caching";
 import { getOwnMachineId, getThreadKeyCert, verifyMachineIdForPublicKey } from "../-a-auth/certs";
-import { getSNICerts, publishMachineARecords } from "../-e-certs/EdgeCertController";
+import { getHostedIP, getSNICerts, publishMachineARecords } from "../-e-certs/EdgeCertController";
 import { LOCAL_DOMAIN, nodePathAuthority } from "../0-path-value-core/NodePathAuthorities";
 import { debugCoreMode, registerGetCompressNetwork, encodeParentFilter, registerGetCompressDisk, authorityStorage } from "../0-path-value-core/pathValueCore";
 import { clientWatcher, ClientWatcher } from "../1-path-client/pathValueClientWatcher";
@@ -67,6 +67,8 @@ let yargObj = parseArgsFactory()
     .option("verbosenetwork", { type: "boolean", desc: "Log all network activity" })
     .option("verboseframework", { type: "boolean", desc: "Log internal SocketFunction framework" })
     .option("nodelay", { type: "boolean", desc: "Don't delay committing functions, even ones that are marked to be delayed." })
+    // 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." })
     .argv
     ;
 setImmediate(() => {
@@ -765,6 +767,13 @@ export class Querysub {
             allowHostnames.push(domain);
         }
         allowHostnames.push("127-0-0-1." + getDomain());
+
+        if (yargObj.bootstraponly && isPublic()) {
+            if (config.port !== 443) {
+                throw new Error(`--bootstraponly requires you to set port 443. There can only be one  bootstrap node per server.`);
+            }
+        }
+
         await SocketFunction.mount({
             public: isPublic(),
             port: config.port,
@@ -780,10 +789,38 @@ export class Querysub {
 
         let { ip, ipDomain } = await publishMachineARecords();
 
-        await registerEdgeNode({
-            host: ipDomain + ":" + config.port,
-            entryPaths,
-        });
+        if (!yargObj.bootstraponly) {
+            await registerEdgeNode({
+                host: ipDomain + ":" + config.port,
+                entryPaths,
+            });
+        } else {
+            // bootstraponly mode. Setup cloudflare proxy. If they are developing (localhost), we can't proxy, so don't (but still setup domain). Using the cloudflare proxy should prevent the site from entirely breaking if the bootstrapper goes down.
+            let ip = await getHostedIP();
+            let existingRecords = await getRecords("A", getDomain());
+            if (ip !== "127.0.0.1") {
+                let validRecords: string[] = [];
+                await Promise.all(existingRecords.map(async (record) => {
+                    let isListening = await timeoutToUndefined(timeInSecond * 10, testTCPIsListening(record, 443));
+                    if (isListening) {
+                        validRecords.push(record);
+                    }
+                }));
+                // It's hard to manage multiple bootstrappers, so... just don't.
+                if (validRecords.length > 0) {
+                    console.error(`Found existing bootstrapper at ${JSON.stringify(validRecords)}, so why are we even running? Terminating shortly`);
+                    // Give logs time to write
+                    await shutdown();
+                }
+                await setRecord("A", getDomain(), ip, "proxied");
+            } else {
+                if (existingRecords.length === 0) {
+                    await setRecord("A", ip, getDomain());
+                } else {
+                    console.log(`Not clobbering existing A record for ${getDomain()} of ${JSON.stringify(existingRecords)}`);
+                }
+            }
+        }
     }
     private static async addSourceMapCheck(config: {
         sourceCheck?: MachineSourceCheck;
@@ -1279,4 +1316,6 @@ import { getCountPerPaint } from "../functional/onNextPaint";
 import { addEpsilons } from "../bits";
 import { blue } from "socket-function/src/formatting/logColors";
 import { MachineController } from "../deployManager/machineController";
+import { getRecords, setRecord } from "../-b-authorities/dnsAuthority";
+import { testTCPIsListening } from "socket-function/src/networking";
 

package/src/deployManager/MachinesPage.tsx

@@ -8,6 +8,7 @@ import { MachinesListPage } from "./components/MachinesListPage";
 import { ServiceDetailPage } from "./components/ServiceDetailPage";
 import { MachineDetailPage } from "./components/MachineDetailPage";
 import { Anchor } from "../library-components/ATag";
+import { DeployPage } from "./components/DeployPage";
 
 export class MachinesPage extends qreact.Component {
     private renderTabs() {
@@ -18,6 +19,7 @@ export class MachinesPage extends qreact.Component {
             {[
                 { key: "machines", label: "Machines", otherKeys: ["machine-detail"] },
                 { key: "services", label: "Services", otherKeys: ["service-detail"] },
+                { key: "deploy", label: "Deploy", otherKeys: [] },
             ].map(tab => {
                 let isActive = currentViewParam.value === tab.key || tab.otherKeys.includes(currentViewParam.value);
                 return <Anchor noStyles key={tab.key}
@@ -44,6 +46,7 @@ export class MachinesPage extends qreact.Component {
                 {currentViewParam.value === "machines" && <MachinesListPage />}
                 {currentViewParam.value === "service-detail" && <ServiceDetailPage />}
                 {currentViewParam.value === "machine-detail" && <MachineDetailPage />}
+                {currentViewParam.value === "deploy" && <DeployPage />}
             </div>
         </div>;
     }