querysub 0.627.0 → 0.628.0

package/package.json

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

package/src/4-deploy/git.ts

@@ -1,19 +1,92 @@
 import * as child_process from "child_process";
 import { cache } from "socket-function/src/caching";
-import { runPromise } from "../functional/runCommand";
 import { measureWrap } from "socket-function/src/profiling/measure";
+import { timeInMinute } from "socket-function/src/misc";
+import { blue, red } from "socket-function/src/formatting/logColors";
+import { formatTime } from "socket-function/src/formatting/format";
 import fs from "fs";
 import os from "os";
 import path from "path";
+
+// Resolving on 'close' (as socket-function's runPromise does) waits for the stdio pipes to close, and git background daemons (ex, fsmonitor, which a plain `git status` auto-starts on Windows) inherit those pipe handles and keep them open forever after git itself has exited. So we resolve on 'exit', giving remaining output this long to drain first.
+const OUTPUT_DRAIN_TIME = 100;
+// A hard ceiling so a wedged command (a fetch that never completes, a credential prompt with no console) fails loudly instead of hanging the caller forever. Generous, as clones of large repos legitimately take minutes.
+const COMMAND_TIMEOUT = 10 * timeInMinute;
+
+async function runGitCommand(command: string, config?: {
+    cwd?: string;
+    quiet?: boolean;
+    nothrow?: boolean;
+}): Promise<string> {
+    if (!config?.quiet) {
+        console.log(">" + blue(command));
+    }
+    return new Promise<string>((resolve, reject) => {
+        let childProc = child_process.spawn(command, {
+            shell: true,
+            cwd: config?.cwd,
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+        let fullOutput = "";
+        let stderr = "";
+        let finished = false;
+        function finish(result: { code: number | null } | { error: Error }) {
+            if (finished) return;
+            finished = true;
+            clearTimeout(timeoutHandle);
+            if ("error" in result) {
+                if (config?.nothrow) {
+                    resolve(fullOutput);
+                } else {
+                    reject(result.error);
+                }
+                return;
+            }
+            if (result.code === 0 || config?.nothrow) {
+                resolve(fullOutput);
+            } else {
+                let errorMessage = `Process exited with code ${result.code} for command: ${command} (cwd ${path.resolve(config?.cwd || ".")})`;
+                if (stderr) {
+                    errorMessage += `\n${stderr}`;
+                }
+                reject(new Error(errorMessage));
+            }
+        }
+        let timeoutHandle = setTimeout(() => {
+            childProc.kill();
+            finish({ error: new Error(`Command timed out after ${formatTime(COMMAND_TIMEOUT)}: ${command} (cwd ${path.resolve(config?.cwd || ".")})\n${fullOutput}`) });
+        }, COMMAND_TIMEOUT);
+        childProc.stdout?.on("data", data => {
+            let chunk = data.toString();
+            fullOutput += chunk;
+            if (!config?.quiet) {
+                process.stdout.write(chunk);
+            }
+        });
+        childProc.stderr?.on("data", data => {
+            let chunk = data.toString();
+            stderr += chunk;
+            fullOutput += chunk;
+            if (!config?.quiet) {
+                process.stderr.write(red(chunk));
+            }
+        });
+        childProc.on("error", error => finish({ error }));
+        childProc.on("exit", code => {
+            setTimeout(() => finish({ code }), OUTPUT_DRAIN_TIME);
+        });
+        childProc.on("close", code => finish({ code }));
+    });
+}
 export async function getGitURLLive(gitDir = ".") {
-    return (await runPromise(`git remote get-url origin`, { cwd: gitDir })).trim();
+    return (await runGitCommand(`git remote get-url origin`, { cwd: gitDir })).trim();
 }
 export async function getGitRefLive(gitDir = ".") {
-    return (await runPromise(`git rev-parse HEAD`, { cwd: gitDir })).trim();
+    return (await runGitCommand(`git rev-parse HEAD`, { cwd: gitDir })).trim();
 }
 
 export async function getGitUncommitted(gitDir = "."): Promise<string[]> {
-    return (await runPromise(`git status --porcelain`, { cwd: gitDir })).split("\n").map(x => x.trim()).filter(x => x);
+    return (await runGitCommand(`git status --porcelain`, { cwd: gitDir })).split("\n").map(x => x.trim()).filter(x => x);
 }
 
 // Cap the diff we hand to the client / AI, so a huge accidental change doesn't
@@ -29,14 +102,14 @@ export async function getGitDiff(gitDir = "."): Promise<string> {
     let sections: string[] = [];
 
     // Tracked modifications (staged + unstaged) relative to the last commit.
-    let trackedDiff = await runPromise(`git diff HEAD`, { cwd: gitDir, quiet: true });
+    let trackedDiff = await runGitCommand(`git diff HEAD`, { cwd: gitDir, quiet: true });
     if (trackedDiff.trim()) {
         sections.push(trackedDiff);
     }
 
     // Untracked files don't show up in `git diff HEAD`, so include their
     //  contents as all-addition hunks.
-    let untrackedFiles = (await runPromise(`git ls-files --others --exclude-standard`, { cwd: gitDir, quiet: true }))
+    let untrackedFiles = (await runGitCommand(`git ls-files --others --exclude-standard`, { cwd: gitDir, quiet: true }))
         .split("\n").map(x => x.trim()).filter(x => x);
     for (let file of untrackedFiles) {
         let content: string;
@@ -72,8 +145,8 @@ export async function getGitDiff(gitDir = "."): Promise<string> {
 }
 
 export async function getLatestRefOnUpstreamBranch(gitDir = ".") {
-    await runPromise(`git fetch`, { cwd: gitDir });
-    return (await runPromise(`git rev-parse @{upstream}`, { cwd: gitDir })).trim();
+    await runGitCommand(`git fetch`, { cwd: gitDir });
+    return (await runGitCommand(`git rev-parse @{upstream}`, { cwd: gitDir })).trim();
 }
 
 export async function commitAndPush(config: {
@@ -85,9 +158,9 @@ export async function commitAndPush(config: {
 
     try {
         await fs.promises.writeFile(tempFile, config.message, "utf8");
-        await runPromise(`git add --all`, { cwd: config.gitDir });
-        await runPromise(`git commit -F "${tempFile}"`, { cwd: config.gitDir });
-        await runPromise(`git push`, { cwd: config.gitDir });
+        await runGitCommand(`git add --all`, { cwd: config.gitDir });
+        await runGitCommand(`git commit -F "${tempFile}"`, { cwd: config.gitDir });
+        await runGitCommand(`git push`, { cwd: config.gitDir });
     } finally {
         // Clean up temporary file
         try {
@@ -105,8 +178,8 @@ export async function getGitRefInfo(config: {
     time: number;
     description: string;
 }> {
-    const timeOutput = await runPromise(`git show --format="%ct" -s ${config.ref}`, { cwd: config.gitDir });
-    const descriptionOutput = await runPromise(`git show --format="%B" -s ${config.ref}`, { cwd: config.gitDir });
+    const timeOutput = await runGitCommand(`git show --format="%ct" -s ${config.ref}`, { cwd: config.gitDir });
+    const descriptionOutput = await runGitCommand(`git show --format="%B" -s ${config.ref}`, { cwd: config.gitDir });
 
     return {
         time: parseInt(timeOutput.trim(), 10) * 1000,
@@ -128,7 +201,7 @@ export const setGitRef = measureWrap(async function setGitRef(config: {
     await fs.promises.mkdir(config.gitFolder, { recursive: true });
     // ssh-keyscan is a network call; a transient failure here must not abort the sync. The host key is normally already in known_hosts from machine setup, and callers only escalate to clobbering the checkout on *repo* failures — not on a momentary inability to refresh a host key.
     try {
-        let hostKey = await runPromise(`ssh-keyscan -t rsa bitbucket.org`);
+        let hostKey = await runGitCommand(`ssh-keyscan -t rsa bitbucket.org`);
         hostKey = hostKey.split("\n").filter(x => !x.startsWith("#")).join("\n");
         let knownHostsPath = os.homedir() + "/.ssh/known_hosts";
         if (hostKey && (!fs.existsSync(knownHostsPath) || !fs.readFileSync(knownHostsPath).toString().includes(hostKey))) {
@@ -138,14 +211,14 @@ export const setGitRef = measureWrap(async function setGitRef(config: {
         console.warn(`ssh-keyscan for bitbucket.org failed, continuing: ${e.stack ?? e}`);
     }
 
-    await runPromise(`git remote update`, { cwd: config.gitFolder });
-    await runPromise(`git add --all`, { cwd: config.gitFolder });
+    await runGitCommand(`git remote update`, { cwd: config.gitFolder });
+    await runGitCommand(`git add --all`, { cwd: config.gitFolder });
     // nothrow: on a freshly re-initialized repo (rebuildGitFolder) there is no initial commit yet, so `git stash` errors. That's harmless — the `git reset --hard` below is what actually forces the working tree to the target ref.
-    await runPromise(`git stash`, { cwd: config.gitFolder, nothrow: true });
-    await runPromise(`git fetch --all`, { cwd: config.gitFolder });
-    await runPromise(`git reset --hard ${config.gitRef}`, { cwd: config.gitFolder });
+    await runGitCommand(`git stash`, { cwd: config.gitFolder, nothrow: true });
+    await runGitCommand(`git fetch --all`, { cwd: config.gitFolder });
+    await runGitCommand(`git reset --hard ${config.gitRef}`, { cwd: config.gitFolder });
     // Allows us to remove deleted objects from storage, ex, if we accidentally commit a 1GB, this deletes it, so we don't have to fix each server individually. Also I think the repo breaks if we go too long without pruning it?
-    await runPromise(`git prune`, { cwd: config.gitFolder });
+    await runGitCommand(`git prune`, { cwd: config.gitFolder });
 });
 
 /** Recovers a broken repo WITHOUT disturbing the working-tree files. We delete only .git, re-init, re-add the remote, then let setGitRef's `git reset --hard` reconcile the tracked files to the ref. Untracked / gitignored files (notably node_modules, which is expensive to reinstall and may be open in a running service) are left exactly as they are. When the directory is empty this produces the same result as a fresh clone. */
@@ -156,8 +229,8 @@ export const rebuildGitFolder = measureWrap(async function rebuildGitFolder(conf
 }) {
     await fs.promises.mkdir(config.gitFolder, { recursive: true });
     await fs.promises.rm(config.gitFolder + ".git", { recursive: true, force: true });
-    await runPromise(`git init`, { cwd: config.gitFolder });
-    await runPromise(`git remote add origin ${config.repoUrl}`, { cwd: config.gitFolder });
+    await runGitCommand(`git init`, { cwd: config.gitFolder });
+    await runGitCommand(`git remote add origin ${config.repoUrl}`, { cwd: config.gitFolder });
     await setGitRef({ gitFolder: config.gitFolder, gitRef: config.gitRef });
 });
 
@@ -170,7 +243,7 @@ export const nuclearReclone = measureWrap(async function nuclearReclone(config:
     let target = config.gitFolder.replace(/[\/\\]+$/, "");
     let tempDir = target + ".reclone-" + Date.now();
     await fs.promises.rm(tempDir, { recursive: true, force: true });
-    await runPromise(`git clone ${config.repoUrl} ${tempDir}`);
+    await runGitCommand(`git clone ${config.repoUrl} ${tempDir}`);
     await setGitRef({ gitFolder: tempDir + "/", gitRef: config.gitRef });
     await fs.promises.rm(target, { recursive: true, force: true });
     await fs.promises.rename(tempDir, target);

package/src/storageSetup.ts

@@ -1,6 +1,7 @@
 process.env.PRODUCTION = "true";
 import { magenta } from "socket-function/src/formatting/logColors";
 import "./inject";
+process.argv.push("--nobreak");
 
 // The storage server entry point (see bin/storageserve.js): sets up the CLI args the sliftutils storage server expects, synchronizes our network trust list into its trust store, and runs its CLI.