querysub 0.327.0 → 0.328.0

package/package.json

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -212,6 +212,9 @@ export interface WatcherOptions<Result> {
     logSyncTimings?: boolean;
 
     maxLocksOverride?: number;
+
+    // NOTE: The reason there isn't throttle support here is very frequently when you want to throttle one component rendering, it's because you have many components. So you actually want to throttle many components and have them throttle in conjunction with each other, which results in the logic becoming complicated.
+    //  - But maybe we should support the single throttle case anyways?
 }
 
 let harvestableReadyLoopCount = 0;

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

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

package/src/4-querysub/Querysub.ts

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

package/src/5-diagnostics/GenericFormat.tsx

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

package/src/deployManager/machineApplyMainCode.ts

@@ -24,9 +24,11 @@ import { shutdown } from "../diagnostics/periodic";
 import { onServiceConfigChange, triggerRollingUpdate } from "./machineController";
 import { PromiseObj } from "../promise";
 import path from "path";
+import { fsExistsAsync } from "../fs";
 
 const PIPE_FILE_LINE_LIMIT = 10_000;
 
+
 const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ value: number; max: number } | undefined> {
     if (os.platform() === "win32") {
         throw new Error("Windows is not supported for machine resource monitoring");
@@ -379,7 +381,7 @@ const getScreenState = measureWrap(async function getScreenState(populateIsProce
 });
 async function removeOldNodeId(screenName: string) {
     let nodeIdFile = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/" + SERVICE_NODE_FILE_NAME;
-    if (fs.existsSync(nodeIdFile)) {
+    if (await fsExistsAsync(nodeIdFile)) {
         let nodeId = await fs.promises.readFile(nodeIdFile, "utf8");
         console.log(green(`Removing node if for dead service on ${nodeIdFile}, node id ${nodeId}`));
         await fs.promises.unlink(nodeIdFile);
@@ -416,7 +418,7 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
         if (existingScreen && !rollingObj && await isScreenRunningProcess(existingScreen.pid)) {
             let nodeIdPath = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/" + SERVICE_NODE_FILE_NAME;
             let rollingFinalTime = Date.now() + config.rollingWindow;
-            if (fs.existsSync(nodeIdPath)) {
+            if (await fsExistsAsync(nodeIdPath)) {
                 let nodeId = await fs.promises.readFile(nodeIdPath, "utf8");
                 // REMOVE the nodeId file, so we the node isn't terminated!
                 await fs.promises.unlink(nodeIdPath);
@@ -551,7 +553,7 @@ const ensureGitSynced = measureWrap(async function ensureGitSynced(config: {
     repoUrl: string;
     gitRef: string;
 }) {
-    if (!await fs.existsSync(config.gitFolder + ".git")) {
+    if (!await fsExistsAsync(config.gitFolder + ".git")) {
         await runPromise(`git clone ${config.repoUrl} ${config.gitFolder}`);
     }
     try {
@@ -595,7 +597,7 @@ async function quickIsOutdated() {
             let folder = root + screenName + "/";
             await fs.promises.mkdir(folder, { recursive: true });
             let parameterPath = folder + "/parameters.json";
-            if (!fs.existsSync(parameterPath)) return true;
+            if (!await fsExistsAsync(parameterPath)) return true;
             let prevParameters = await fs.promises.readFile(parameterPath, "utf8");
             if (prevParameters !== newParametersString) return true;
         }
@@ -654,7 +656,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 }
                 let parameterPath = folder + "/parameters.json";
                 let prevParameters = "";
-                if (fs.existsSync(parameterPath)) {
+                if (await fsExistsAsync(parameterPath)) {
                     prevParameters = await fs.promises.readFile(parameterPath, "utf8");
                 }
                 let newParametersString = JSON.stringify(config.parameters);
@@ -673,7 +675,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 await fs.promises.writeFile(parameterPath, newParametersString);
 
                 let nodePathId = folder + SERVICE_NODE_FILE_NAME;
-                if (fs.existsSync(nodePathId)) {
+                if (await fsExistsAsync(nodePathId)) {
                     let nodeId = await fs.promises.readFile(nodePathId, "utf8");
                     machineInfo.services[config.serviceId].nodeId = nodeId;
                 }
@@ -788,7 +790,7 @@ export async function machineApplyMain() {
 
     // NOTE: Error's don't get logged unless we host, so... we can't do this earlier than this...
     let lastErrorPath = os.homedir() + "/lastAlwaysUpError.txt";
-    if (fs.existsSync(lastErrorPath)) {
+    if (await fsExistsAsync(lastErrorPath)) {
         let lastError = await fs.promises.readFile(lastErrorPath, "utf8");
         await fs.promises.unlink(lastErrorPath);
         console.error(`Always up error: ${lastError}`);
@@ -796,7 +798,7 @@ export async function machineApplyMain() {
 
     // Kill the last running one
     let isRunningPath = os.homedir() + "/machineApplyPID.txt";
-    if (fs.existsSync(isRunningPath)) {
+    if (await fsExistsAsync(isRunningPath)) {
         let pid = await fs.promises.readFile(isRunningPath, "utf8");
         try {
             process.kill(parseInt(pid), "SIGKILL");

package/src/deployManager/machineSchema.ts

@@ -23,6 +23,7 @@ import { DeployProgress, deployFunctions, deployGetFunctions } from "../4-deploy
 import { FunctionSpec, functionSchema } from "../3-path-functions/PathFunctionRunner";
 import { Querysub } from "../4-querysub/QuerysubController";
 import { green, red } from "socket-function/src/formatting/logColors";
+import { fsExistsAsync } from "../fs";
 
 const SERVICE_FOLDER_NAME = "machine-services";
 export const SERVICE_FOLDER = `${SERVICE_FOLDER_NAME}/`;
@@ -240,7 +241,7 @@ export class MachineServiceControllerBase {
         let querysubFolder = path.resolve("../querysub");
         let querysubRef = "";
         let querysubUncommitted: string[] = [];
-        if (fs.existsSync(querysubFolder)) {
+        if (await fsExistsAsync(querysubFolder)) {
             querysubRef = await getGitRefLive(querysubFolder);
             querysubUncommitted = await getGitUncommitted(querysubFolder);
         }
@@ -276,7 +277,7 @@ export class MachineServiceControllerBase {
     public async commitPushService(commitMessage: string) {
         if (commitMessage.toLowerCase().includes("querysub")) {
             let querysubFolder = path.resolve("../querysub");
-            if (fs.existsSync(querysubFolder)) {
+            if (await fsExistsAsync(querysubFolder)) {
                 let querysubLastCommit = await getGitRefInfo({
                     gitDir: querysubFolder,
                     ref: "origin/main",
@@ -293,7 +294,7 @@ export class MachineServiceControllerBase {
     }
     public async commitPushAndPublishQuerysub(commitMessage: string) {
         let querysubFolder = path.resolve("../querysub");
-        if (!fs.existsSync(querysubFolder)) {
+        if (!await fsExistsAsync(querysubFolder)) {
             throw new Error(`Querysub folder does not exist at ${querysubFolder}`);
         }
 

package/src/deployManager/setupMachineMain.ts

@@ -6,6 +6,7 @@ import fs from "fs";
 import os from "os";
 import readline from "readline";
 import open from "open";
+import { fsExistsAsync } from "../fs";
 // Import querysub, to fix missing dependencies
 Querysub;
 
@@ -32,7 +33,7 @@ async function getGitHubApiKey(repoUrl: string, sshRemote: string): Promise<stri
     const cacheFile = os.homedir() + `/githubkey_${repoOwner}_${repoName}.json`;
 
     // Check if we have a cached key
-    if (fs.existsSync(cacheFile)) {
+    if (await fsExistsAsync(cacheFile)) {
         try {
             const cached = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
             if (cached.apiKey) {
@@ -222,7 +223,7 @@ async function main() {
 
     // 1. Copy backblaze file to remote server (~/backblaze.json)
     console.log("Copying backblaze credentials...");
-    if (fs.existsSync(backblazePath)) {
+    if (await fsExistsAsync(backblazePath)) {
         await runPromise(`scp "${backblazePath}" ${sshRemote}:~/backblaze.json`);
         console.log("✅ Backblaze credentials copied");
     } else {