querysub 0.535.0 → 0.536.0

package/.claude/settings.local.json

@@ -30,7 +30,8 @@
       "WebFetch(domain:blog.cloudflare.com)",
       "WebFetch(domain:developers.cloudflare.com)",
       "PowerShell(yarn type *)",
-      "PowerShell(Remove-Item -Confirm:$false \"C:\\\\Users\\\\quent\\\\.claude\\\\projects\\\\D--repos-querysub\\\\memory\\\\no-naming-new-bins.md\")"
+      "PowerShell(Remove-Item -Confirm:$false \"C:\\\\Users\\\\quent\\\\.claude\\\\projects\\\\D--repos-querysub\\\\memory\\\\no-naming-new-bins.md\")",
+      "Bash(python -)"
     ]
   }
 }

package/appSecrets.ts

@@ -1,12 +1,82 @@
 import fs from "fs";
-import { getBackblazePath } from "./src/-a-archives/archivesBackBlaze";
-import { getCloudflareCreds } from "./src/-b-authorities/cloudflareHelpers";
+import os from "os";
+import { isNode } from "socket-function/src/misc";
+import { lazy } from "socket-function/src/caching";
+import { ArchivesBackblaze } from "sliftutils/storage/backblaze";
+import { parseArgsFactory } from "./src/misc/rawParams";
 import { Querysub } from "./src/4-querysub/Querysub";
 
+// getSecret always imports us relative to the process cwd, so the cwd is the repo root and this matches what getStorageDir would resolve
+const STORAGE_DIR = "./database-storage/";
+
+// querysubConfig and getDomain are copied verbatim from src/config.ts, so this file has no dependencies on our own application (parseArgsFactory is fine to import, as it has no dependencies of its own)
+
+let yargObj = parseArgsFactory()
+    .option("domain", { type: "string", desc: `Sets the domain` })
+    .argv
+    ;
+
+type QuerysubConfig = {
+    domain?: string;
+    emaildomain?: string;
+    notifyemails?: string[];
+};
+let querysubConfig = lazy((): QuerysubConfig => {
+    if (!isNode()) throw new Error("querysubConfig is only available on the server");
+    const path = "./querysub.json";
+    if (!fs.existsSync(path)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(path, "utf8"));
+    } catch (e) {
+        console.error("Error parsing querysub.json", e);
+        return {};
+    }
+});
+
+export function getDomain() {
+    if (!isNode()) {
+        return location.hostname.split(".").slice(-2).join(".");
+    }
+    return yargObj.domain || querysubConfig().domain || "querysub.com";
+}
+
+const keysArchives = lazy(() => new ArchivesBackblaze({ bucketName: getDomain() }));
+
+export function getBackblazePath() {
+    let testPaths = [
+        STORAGE_DIR + "backblaze.json",
+        os.homedir() + "/backblaze.json",
+    ];
+    for (let path of testPaths) {
+        if (fs.existsSync(path)) {
+            return path;
+        }
+    }
+    return testPaths[0];
+}
+
+export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: string }> => {
+    let archives = keysArchives();
+    let credsJSON = await archives.get("keys/cloudflare.json");
+    if (!credsJSON) {
+        let localPath = STORAGE_DIR + "cloudflare.json";
+        if (fs.existsSync(localPath)) {
+            credsJSON = fs.readFileSync(localPath);
+            await archives.set("keys/cloudflare.json", credsJSON);
+        } else {
+            throw new Error(`b2:/keys/cloudflare.json is missing. It should contain { "key": "your-key", "email": "your-email" }`);
+        }
+    }
+    return JSON.parse(credsJSON.toString());
+});
+
 /** Serves the secret keys sliftutils' getSecret expects, reading them the way querysub already does: backblaze creds off disk (getBackblazePath), cloudflare creds from the keys archives bucket (with its local file fallback). */
 export async function getAppSecret(key: string): Promise<string | undefined> {
-    // Use this so some of our default imports get imported
-    Querysub;
+    // todonext;
+    //  Add this back after we finish testing. We need this in order to get logging, but for testing, It just adds extra logging, which is annoying and slows down runs. 
+    // Querysub;
     if (key.startsWith("backblaze.json.")) {
         let creds = JSON.parse(fs.readFileSync(getBackblazePath(), "utf8")) as { applicationKeyId?: string; applicationKey?: string };
         if (key === "backblaze.json.applicationKeyId") return creds.applicationKeyId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.535.0",
+  "version": "0.536.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -71,8 +71,8 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.18",
-    "socket-function": "^1.2.24",
+    "sliftutils": "^1.7.20",
+    "socket-function": "^1.2.25",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",
     "typesafecss": "^0.32.0",

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

@@ -18,7 +18,7 @@ export interface Archives {
         // Skips checking if the file exists on the remote. Only appropriate when the file name is fresh (recently obtained from find).
         fastRead?: boolean;
     }): Promise<Buffer | undefined>;
-    set(path: string, data: Buffer): Promise<void>;
+    set(path: string, data: Buffer): Promise<string | void>;
     del(path: string): Promise<void>;
 
     append(path: string, data: Buffer): Promise<void>;

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

@@ -1,28 +1,15 @@
 import { cache } from "socket-function/src/caching";
-import { getStorageDir } from "../fs";
 import { Archives } from "./archives";
 import fs from "fs";
-import os from "os";
 import { isNode, timeInMinute } from "socket-function/src/misc";
 import { isLogBackblaze } from "../config";
+import { getBackblazePath } from "../../appSecrets";
 import { ArchivesBackblaze as ArchivesBackblazeBase } from "sliftutils/storage/backblaze";
 import type { IArchives, ArchivesConfig } from "sliftutils/storage/IArchives";
 
 export function hasBackblazePermissions() {
     return isNode() && fs.existsSync(getBackblazePath());
 }
-export function getBackblazePath() {
-    let testPaths = [
-        getStorageDir() + "backblaze.json",
-        os.homedir() + "/backblaze.json",
-    ];
-    for (let path of testPaths) {
-        if (fs.existsSync(path)) {
-            return path;
-        }
-    }
-    return testPaths[0];
-}
 
 // The implementation lives in sliftutils (it reads credentials via getSecret, which our appSecrets.ts serves from getBackblazePath). We forward to an inner instance instead of subclassing, because our Archives interface's move/copy take a querysub Archives target (with getBaseArchives unwrapping) which is type-incompatible with the base class's IArchives signatures.
 export class ArchivesBackblaze {

package/src/deployManager/machineApplyMainCode.ts

@@ -696,7 +696,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 try {
                     await ensureOldInstance({
                         old: { ...oldParameters, command: applyCommandTemplate(oldParameters.command, oldTargets[i].variables) },
-                        aliveWindow: [releaseTime, releaseTime + overlapTime],
+                        aliveWindow: [oldParameters.releaseTime || 0, releaseTime + overlapTime],
                         index: i,
                         screenNamesUsed,
                         screenStateMap,
@@ -764,9 +764,10 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 let screenIsRunning = screenStateMap.get(screenName)?.isProcessRunning;
 
                 const syncTimeline = async (pid: string | undefined) => {
+                    // The windows overlap: a version runs from its releaseTime until the NEXT version's releaseTime + overlapTime (the overlap is when both run)
                     let entries: ParametersTimelineEntry[] = [{
                         pid: parseInt(pid || "") || undefined,
-                        aliveWindow: [config.parameters.releaseTime || 0, isUpcomingRelease ? releaseTime : ALIVE_WINDOW_FOREVER],
+                        aliveWindow: [config.parameters.releaseTime || 0, isUpcomingRelease ? releaseTime + overlapTime : ALIVE_WINDOW_FOREVER],
                         parameters: instanceParameters,
                     }];
                     if (isUpcomingRelease) {
@@ -778,6 +779,15 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                             });
                         }
                     }
+                    if (isOverlapRunning && record.oldParameters) {
+                        let oldTargets = getMachineTargets(record.oldParameters).filter(target => target.machineId === machineId);
+                        if (i < oldTargets.length) {
+                            entries.push({
+                                aliveWindow: [record.oldParameters.releaseTime || 0, releaseTime + overlapTime],
+                                parameters: { ...record.oldParameters, command: applyCommandTemplate(record.oldParameters.command, oldTargets[i].variables) },
+                            });
+                        }
+                    }
                     await syncParametersTimelineFiles(folder, entries);
                 };
 

package/src/deployManager/setupMachineMain.ts

@@ -1,4 +1,4 @@
-import { getBackblazePath } from "../-a-archives/archivesBackBlaze";
+import { getBackblazePath } from "../../appSecrets";
 import { getGitURLLive, getGitRefLive } from "../4-deploy/git";
 import { Querysub } from "../4-querysub/Querysub";
 import { runPromise } from "../functional/runCommand";

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

@@ -1,20 +0,0 @@
-import { getArchives } from "../-a-archives/archives";
-import { lazy } from "socket-function/src/caching";
-import { getStorageDir } from "../fs";
-import fs from "fs";
-
-const keys = lazy(() => getArchives("keys"));
-
-export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: string }> => {
-    let credsJSON = await keys().get("cloudflare.json");
-    if (!credsJSON) {
-        let localPath = getStorageDir() + "cloudflare.json";
-        if (fs.existsSync(localPath)) {
-            credsJSON = fs.readFileSync(localPath);
-            await keys().set("cloudflare.json", credsJSON);
-        } else {
-            throw new Error(`b2:/keys/cloudflare.json is missing. It should contain { "key": "your-key", "email": "your-email" }`);
-        }
-    }
-    return JSON.parse(credsJSON.toString());
-});