querysub 0.656.0 → 0.658.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.656.0",
+  "version": "0.658.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -79,8 +79,8 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.128",
-    "socket-function": "^1.2.34",
+    "sliftutils": "^1.7.130",
+    "socket-function": "^1.2.35",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",
     "typesafecss": "^0.32.0",

package/src/deployManager/components/CommitModal.tsx

@@ -80,12 +80,12 @@ function extractChangedLines(diff: string): string {
 const rowButtonStyle = css.pad2(12, 8).button.bord2(0, 0, 20).fontWeight("bold");
 
 export class CommitModal extends qreact.Component<{
-    /** True for the querysub repo, false for the main service repo. */
-    isQuerysub?: boolean;
+    /** True when the commit also publishes querysub, so the diff covers both repos and the labels say so. */
+    includeQuerysub?: boolean;
     /** The `git status --porcelain` lines, shown as a file list. */
     changes: string[];
-    /** Performs the actual commit + push (and publish, for querysub). */
-    onCommit: (message: string) => Promise<void>;
+    /** Performs the actual commit + push (and publish, for querysub). Calls setStep as it moves through its steps, which is shown on the commit button. */
+    onCommit: (message: string, setStep: (step: string) => void) => Promise<void>;
 }> {
     state = t.state({
         message: t.string,
@@ -96,6 +96,7 @@ export class CommitModal extends qreact.Component<{
         diffLoading: t.boolean(true),
         summarizing: t.boolean(false),
         committing: t.boolean(false),
+        step: t.string,
         error: t.string,
         lastCost: t.number,
     });
@@ -108,9 +109,13 @@ export class CommitModal extends qreact.Component<{
 
     private async loadDiff() {
         try {
-            let isQuerysub = Querysub.localRead(() => this.props.isQuerysub);
+            let includeQuerysub = Querysub.localRead(() => this.props.includeQuerysub);
             let controller = MachineServiceController(SocketFunction.browserNodeId());
-            let diff = await controller.getGitDiff.promise({ useQuerysub: isQuerysub });
+            let diffs = await Promise.all([
+                includeQuerysub && controller.getGitDiff.promise({ useQuerysub: true }) || "",
+                controller.getGitDiff.promise({ useQuerysub: false }),
+            ]);
+            let diff = diffs.filter(x => x).join("\n");
             console.log("Received commit diff, changed lines:\n" + extractChangedLines(diff));
             Querysub.localCommit(() => {
                 this.state.diff = diff;
@@ -172,22 +177,28 @@ export class CommitModal extends qreact.Component<{
         }
         Querysub.localCommit(() => {
             this.state.committing = true;
+            this.state.step = "";
             this.state.error = "";
         });
         try {
-            await this.props.onCommit(message);
+            await this.props.onCommit(message, step => {
+                Querysub.localCommit(() => {
+                    this.state.step = step;
+                });
+            });
             closeAllModals();
         } catch (e: any) {
             Querysub.localCommit(() => {
                 this.state.error = `Commit failed: ${e.stack ?? e}`;
                 this.state.committing = false;
+                this.state.step = "";
             });
         }
     }
 
     render() {
         let { diff, diffLoading, summarizing, committing } = this.state;
-        let commitLabel = this.props.isQuerysub ? "Publish & Commit & Push" : "Commit & Push";
+        let commitLabel = this.props.includeQuerysub && "Publish Querysub & Commit & Push" || "Commit & Push";
 
         let summarizeLabel: string;
         if (diffLoading) {
@@ -274,7 +285,7 @@ export class CommitModal extends qreact.Component<{
                     disabled={committing}
                     onClick={() => void this.doCommit()}
                 >
-                    {committing ? `⏳ Running ${commitLabel}…` : `⬆️ ${commitLabel}`}
+                    {committing && `⏳ ${this.state.step || `Running ${commitLabel}…`}` || `⬆️ ${commitLabel}`}
                 </button>
             </div>
 

package/src/deployManager/components/deployButtons.tsx

@@ -145,46 +145,45 @@ export class UpdateButtons extends qreact.Component<{
         });
         let outdatedRefs = unique(outdatedServices.map(service => service.parameters.gitRef));
 
+        let querysubChanges = gitInfo?.querysubUncommitted ?? [];
+        let serviceChanges = gitInfo?.uncommitted ?? [];
+        let allChanges = [
+            ...querysubChanges.map(change => `querysub: ${change}`),
+            ...serviceChanges,
+        ];
+        let includeQuerysub = !!querysubChanges.length;
+
         return <>
-            {!!gitInfo?.querysubUncommitted.length && <button
+            {!!allChanges.length && gitInfo && <button
                 className={buttonStyle.hsl(260, 60, 90)}
-                title={gitInfo?.querysubUncommitted.join("\n")}
+                title={allChanges.join("\n")}
                 onClick={() => {
                     showFullscreenModal({
                         content: <CommitModal
-                            isQuerysub
-                            changes={gitInfo?.querysubUncommitted ?? []}
-                            onCommit={async message => {
-                                await controller.commitPushAndPublishQuerysub.promise(message);
+                            includeQuerysub={includeQuerysub}
+                            changes={allChanges}
+                            onCommit={async (message, setStep) => {
+                                if (includeQuerysub) {
+                                    setStep("Step 1/2: Publishing querysub (version bump, npm publish, commit & push, package.json update)…");
+                                    await controller.commitPushAndPublishQuerysub.promise(message);
+                                    setStep("Step 2/2: Committing & pushing the service repo…");
+                                } else {
+                                    setStep("Committing & pushing the service repo…");
+                                }
+                                await controller.commitPushService.promise(message);
                             }}
                         />
                     });
                 }}
             >
                 <div>
-                    {bigEmoji("📚", -5)}
-                    Publish & Commit & Push Querysub & Update Package.json ({gitInfo?.querysubUncommitted.length} Files Changed)
+                    {bigEmoji(includeQuerysub && "📚" || "⬆️", -5)}
+                    {includeQuerysub && "Publish Querysub & " || ""}Commit & Push All ({includeQuerysub && `${querysubChanges.length} querysub + ` || ""}{serviceChanges.length} Files Changed)
                 </div>
-                <div className={css.hbox(5)}>
+                {includeQuerysub && <div className={css.hbox(5)}>
                     <b>Current</b>
                     <RenderGitRefInfo gitRef={gitInfo.querysubRef} isQuerysub />
-                </div>
-            </button>}
-            {!!gitInfo?.uncommitted.length && <button
-                className={buttonStyle.hsl(210, 40, 90)}
-                title={gitInfo?.uncommitted.join("\n")}
-                onClick={() => {
-                    showFullscreenModal({
-                        content: <CommitModal
-                            changes={gitInfo?.uncommitted ?? []}
-                            onCommit={async message => {
-                                await controller.commitPushService.promise(message);
-                            }}
-                        />
-                    });
-                }}
-            >
-                {bigEmoji("⬆️")} <span>Commit & Push ({gitInfo?.uncommitted.length} Files Changed)</span>
+                </div>}
             </button>}
 
             {outdatedServices.length > 0 && gitInfo && <>

package/src/deployManager/setupMachineMain.ts

@@ -114,6 +114,12 @@ async function writeRemoteFile(sshRemote: string, remotePath: string, content: s
     await runPromise(`ssh ${sshRemote} "echo ${encoded} | base64 -d | ${write}"`);
 }
 
+/** Reads one value off the remote: the last line of the command's output, since banners and connection chatter come before it. */
+async function sshValue(sshRemote: string, command: string, config?: { nothrow?: boolean }): Promise<string> {
+    let output = await runPromise(`ssh ${sshRemote} "${command}"`, { nothrow: config?.nothrow });
+    return (output.trim().split("\n").at(-1) || "").trim();
+}
+
 function getGitHubKeyCachePath(repoUrl: string): string {
     let repoOwner = "";
     let repoName = "";
@@ -433,6 +439,17 @@ async function main() {
         console.log("✅ Build tools installed");
     }
 
+    // The daemon runs everything in tmux screens, so setup cannot get by without it
+    console.log("Ensuring tmux is installed...");
+    try {
+        await runPromise(`ssh ${sshRemote} "which tmux"`);
+        console.log("✅ Tmux already installed");
+    } catch {
+        console.log("Installing tmux...");
+        await runPromise(`ssh ${sshRemote} "sudo apt install -y tmux"`);
+        console.log("✅ Tmux installed");
+    }
+
     // 3. Ensure nodejs is installed on remote server
     console.log("Ensuring Node.js is installed...");
     try {
@@ -461,8 +478,9 @@ async function main() {
     await runPromise(`ssh ${sshRemote} "sudo timedatectl set-timezone America/New_York"`);
     console.log("✅ Timezone set to America/New_York");
 
+    // Via .tmux.conf rather than set-option, as set-option needs a running tmux server and there is none on a fresh machine
     console.log(`Setting tmux scrollback history to 100000...`);
-    await runPromise(`ssh ${sshRemote} "tmux set-option -g history-limit 100000"`);
+    await runPromise(`ssh ${sshRemote} "grep -qxF 'set-option -g history-limit 100000' ~/.tmux.conf 2>/dev/null || echo 'set-option -g history-limit 100000' >> ~/.tmux.conf"`);
     console.log("✅ Tmux scrollback history set to 100000");
 
     // 5. Clone current repo into ~/machine-alwaysup with SSH key handling for private repos
@@ -491,7 +509,7 @@ async function main() {
             }
 
             // Get the public key from remote machine
-            const sshPublicKey = await runPromise(`ssh ${sshRemote} "cat ~/.ssh/id_rsa.pub"`);
+            const sshPublicKey = await sshValue(sshRemote, "cat ~/.ssh/id_rsa.pub");
             const keyTitle = `Machine Setup - ${sshRemote} - ${new Date().toISOString()}`;
 
             // Add the deploy key to GitHub repository
@@ -513,8 +531,8 @@ async function main() {
     console.log("✅ Dependencies installed");
 
     // 6. Install the daemon that keeps the machine process running
-    let remoteUser = (await runPromise(`ssh ${sshRemote} "whoami"`)).trim();
-    let remoteHome = (await runPromise(`ssh ${sshRemote} "echo $HOME"`)).trim();
+    let remoteUser = await sshValue(sshRemote, "whoami");
+    let remoteHome = await sshValue(sshRemote, "echo $HOME");
     console.log(`Installing the ${SERVICE_UNIT_NAME} daemon (user ${remoteUser}, home ${remoteHome})...`);
     await writeRemoteFile(sshRemote, `~/${DAEMON_SCRIPT_NAME}`, getDaemonScript(remoteHome), false);
     await runPromise(`ssh ${sshRemote} "chmod +x ~/${DAEMON_SCRIPT_NAME}"`);
@@ -560,7 +578,7 @@ sudo systemctl start ${SERVICE_UNIT_NAME}
     let screenDeadline = Date.now() + SCREEN_VERIFY_TIMEOUT;
     let screenUp = false;
     while (Date.now() < screenDeadline) {
-        let panePid = (await runPromise(`ssh ${sshRemote} "tmux list-panes -t ${SERVICE_NAME} -F '#{pane_pid}' 2>/dev/null || true"`, { nothrow: true })).trim();
+        let panePid = await sshValue(sshRemote, `tmux list-panes -t ${SERVICE_NAME} -F '#{pane_pid}' 2>/dev/null || true`, { nothrow: true });
         if (panePid) {
             screenUp = true;
             break;

package/src/diagnostics/logs/diskShimConsoleLogs.ts

@@ -16,6 +16,8 @@ export function shimConsoleLogs() {
             console.error(`Uncaught exception: ${String(error.stack || error)}`);
         });
     }
+    // Shared across log/warn/error/info, as writing one type can log another
+    let insideLogDisk = false;
     function hookConsoleFnc(fncName: "log" | "warn" | "error" | "info") {
         let console = globalThis.console;
         let originalFnc = console[fncName];
@@ -28,10 +30,17 @@ export function shimConsoleLogs() {
                 if (
                     args.length > 0
                     && String(args[0]).trim().length > 0
+                    // Writing a log can itself log (ex, building the log path generates the identity CA on a fresh machine, which logs), which would recurse forever. Those inner logs only go to the real console below, skipping the disk.
+                    && !insideLogDisk
                 ) {
-                    // Assign to a variable, so it isn't shimmed by injectFileLocationToConsole
-                    const logDiskThatIsntShimmed = diskLogger.logDisk;
-                    logDiskThatIsntShimmed(fncName, ...args);
+                    insideLogDisk = true;
+                    try {
+                        // Assign to a variable, so it isn't shimmed by injectFileLocationToConsole
+                        const logDiskThatIsntShimmed = diskLogger.logDisk;
+                        logDiskThatIsntShimmed(fncName, ...args);
+                    } finally {
+                        insideLogDisk = false;
+                    }
                 }
 
                 // Filter out objects added by injectFileLocationToConsole