querysub 0.443.0 → 0.446.0

package/.claude/settings.local.json

@@ -2,7 +2,16 @@
   "permissions": {
     "allow": [
       "Bash(Get-ChildItem *)",
-      "mcp__querysub-logs__searchIndexes"
+      "mcp__querysub-logs__searchIndexes",
+      "mcp__node-debugger__listNodes",
+      "mcp__node-debugger__attach",
+      "mcp__node-debugger__evaluate",
+      "mcp__node-debugger__attachNode",
+      "mcp__node-debugger__getSource",
+      "mcp__node-debugger__logpoint",
+      "Bash(claude mcp *)",
+      "mcp__querysub-logs__search",
+      "Bash(yarn type *)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.443.0",
+  "version": "0.446.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -21,7 +21,9 @@
     "audit-imports": "yarn typenode ./src/diagnostics/auditImportViolations.ts",
     "test": "yarn typenode ./test.ts",
     "mcp": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts",
-    "mc": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts --cwd D:/repos/qs-cyoa/"
+    "mc": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts --cwd D:/repos/qs-cyoa/",
+    "mcp2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts",
+    "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/"
   },
   "bin": {
     "deploy": "./bin/deploy.js",

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

@@ -396,7 +396,11 @@ export class ArchivesBackblaze {
         public?: boolean;
         immutable?: boolean;
         cacheTime?: number;
-    }) { }
+        allowedOrigins?: string[];
+    }) {
+        // Get the api, to setup cors
+        void this.getBucketAPI();
+    }
 
     private bucketName = this.config.bucketName.replaceAll(/[^\w\d]/g, "-");
     private bucketId = "";
@@ -425,7 +429,7 @@ export class ArchivesBackblaze {
         // ALWAYS set access control, as we can make urls for private buckets with getDownloadAuthorization
         let desiredCorsRules = [{
             corsRuleName: "allowAll",
-            allowedOrigins: ["https"],
+            allowedOrigins: this.config.allowedOrigins ?? ["https"],
             allowedOperations: ["b2_download_file_by_id", "b2_download_file_by_name"],
             allowedHeaders: ["range"],
             exposeHeaders: ["x-bz-content-sha1"],
@@ -1024,7 +1028,8 @@ export const getArchivesBackblazePublicImmutable = cache((domain: string) => {
     return new ArchivesBackblaze({
         bucketName: domain + "-public-immutable",
         public: true,
-        immutable: true
+        immutable: true,
+        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
     });
 });
 
@@ -1036,5 +1041,6 @@ export const getArchivesBackblazePublic = cache((domain: string) => {
         bucketName: domain + "-public",
         public: true,
         cacheTime: timeInMinute,
+        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
     });
 });

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

@@ -36,10 +36,11 @@ export type AuthoritySpec = {
     // If the path.startsWith(prefix), but prefix !== path, then we hash getPathIndex(path, hashIndex)
     //  - For now, let's just never add overlapping prefixes.
     prefixes: PrefixMatcher[];
+    //  - Make sure to set this if you just want the prefix values, otherwise you will get all that that prefixes don't match (the prefixes exclude prefix match but where route does not match).
     excludeDefault?: boolean;
 };
 
-
+// If you want to match just a simple path, use parsePrefixMatcher. It won't match ===, so get the parent if you want that (and then filter the result).
 export type PrefixMatcher = {
     prefix: string;
     additionalMatches: {
@@ -59,7 +60,6 @@ function matchesPrefix(matcher: PrefixMatcher, path: string): boolean {
             return false;
         }
     }
-    if (getPathIndex(path, matcher.childKeyIndex) === undefined) return false;
     return true;
 }
 // Checks if they're asking for the exact prefix, which would mean that the children would be the direct children of this prefix matcher. 

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

@@ -451,7 +451,7 @@ export class PathValueArchives {
 
     private static valuePathCountCache: { time: number; count: Promise<number> } | undefined;
     public static async getValuePathCount(): Promise<number> {
-        const ONE_HOUR = 60 * 60 * 1000;
+        const ONE_HOUR = 15 * 60 * 1000;
         let cache = PathValueArchives.valuePathCountCache;
         if (cache && Date.now() - cache.time < ONE_HOUR) {
             return cache.count;

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1492,12 +1492,9 @@ export class PathValueProxyWatcher {
                     }
                     watcher.countSinceLastFullSync++;
                     if (watcher.countSinceLastFullSync > 10) {
-                        require("debugbreak")(2);
-                        debugger;
                         console.warn(`Watcher ${watcher.debugName} has been unsynced for ${watcher.countSinceLastFullSync} times. This is fine, but maybe optimize it. Why is it cascading?`, { lastUnsyncedAccesses: watcher.lastUnsyncedAccesses, lastUnsyncedParentAccesses: watcher.lastUnsyncedParentAccesses }, watcher.options.watchFunction);
                     }
                     if (watcher.countSinceLastFullSync > 500) {
-                        debugger;
                         // NOTE: Using forceEqualWrites will also fix this a lot of the time, such as when
                         //  a write contains random numbers or dates.
                         let errorMessage = `Too many attempts (${watcher.countSinceLastFullSync}) to sync with different values. If you are reading in a loop, make sure to read all the values, instead of aborting the loop if a value is not synced. ALSO, make sure you don't access paths with Math.random() or Date.now(). This will prevent the sync loop from ever stabilizing.`;

package/src/2-proxy/TransactionDelayer.ts

@@ -88,5 +88,5 @@ export function waitIfReceivedIncompleteTransaction(watcher: SyncWatcher) {
     // This really nicely both blocks it from finishing because of the waiting for the promise and also triggers it automatically when the delay finishes. HOWEVER, In practice, the promise should never be required to trigger it. It should trigger when we receive the missing parts of the transaction, which we will be, of course, watching as they're in the path values that we're accessing. The timeout is just in case something goes wrong and we incorrectly think we should receive the values, but we won't. That way, eventually, we do commit the value. 
     // ALSO! Plus the hash I think only stores like 48 bits. So the chance of collision is somewhat high, especially if we're accessing thousands of paths. So sometimes this will trigger even though we're not missing any part just because we had a collision between the path hashes. 
     proxyWatcher.triggerOnPromiseFinish(promise, { waitReason: "Missing transaction part" });
-    console.error(`(NOT an error, convert this to a warning after we finish testing). Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
+    console.warn(`(NOT an error, convert this to a warning after we finish testing). Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
 }

package/src/4-deploy/git.ts

@@ -16,6 +16,61 @@ export async function getGitUncommitted(gitDir = "."): Promise<string[]> {
     return (await runPromise(`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
+//  blow up the request (or the AI's context window).
+const MAX_DIFF_CHARS = 200_000;
+// Per-file cap for untracked files, so a single large new file doesn't dominate.
+const MAX_UNTRACKED_FILE_CHARS = 20_000;
+
+/** Returns a unified-diff-style summary of all uncommitted changes (tracked
+ *      modifications plus the contents of untracked files), suitable for feeding
+ *      to an AI for summarization. Output is capped at MAX_DIFF_CHARS. */
+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 });
+    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 }))
+        .split("\n").map(x => x.trim()).filter(x => x);
+    for (let file of untrackedFiles) {
+        let content: string;
+        try {
+            content = await fs.promises.readFile(path.join(gitDir, file), "utf8");
+        } catch (e: any) {
+            sections.push(`--- /dev/null\n+++ b/${file}\n(could not read file: ${e.stack ?? e})`);
+            continue;
+        }
+        let isBinary = false;
+        for (let i = 0; i < content.length; i++) {
+            if (content.charCodeAt(i) === 0) {
+                isBinary = true;
+                break;
+            }
+        }
+        if (isBinary) {
+            sections.push(`--- /dev/null\n+++ b/${file}\n(binary file, ${content.length} bytes)`);
+            continue;
+        }
+        if (content.length > MAX_UNTRACKED_FILE_CHARS) {
+            content = content.slice(0, MAX_UNTRACKED_FILE_CHARS) + `\n(... file truncated)`;
+        }
+        let addedLines = content.split("\n").map(line => "+" + line).join("\n");
+        sections.push(`--- /dev/null\n+++ b/${file} (new file)\n${addedLines}`);
+    }
+
+    let diff = sections.join("\n\n");
+    if (diff.length > MAX_DIFF_CHARS) {
+        diff = diff.slice(0, MAX_DIFF_CHARS) + `\n\n(... diff truncated, ${diff.length - MAX_DIFF_CHARS} more characters)`;
+    }
+    return diff;
+}
+
 export async function getLatestRefOnUpstreamBranch(gitDir = ".") {
     await runPromise(`git fetch`, { cwd: gitDir });
     return (await runPromise(`git rev-parse @{upstream}`, { cwd: gitDir })).trim();
@@ -29,7 +84,7 @@ export async function commitAndPush(config: {
     const tempFile = path.join(os.tmpdir(), `commit-message-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.txt`);
 
     try {
-        await fs.promises.writeFile(tempFile, config.message, 'utf8');
+        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 });

package/src/4-querysub/QuerysubController.ts

@@ -237,6 +237,8 @@ export function anyPredictionsPending() {
 }
 export const debug_anyPredictionsPending = anyPredictionsPending;
 export async function waitUntilAllPredictionsFinish() {
+    // HACK: Commit an empty function to allow predictions to queue. Now great, and it only works if the predictions can run right away, but... fixes a lot of bugs, most of the time.
+    await Querysub.commitAsync(() => { });
     while (anyPredictionsPending()) {
         try {
             await Promise.allSettled(Array.from(pendingPredictedCalls.values()).map(obj => obj.obj.promise));

package/src/4-querysub/querysubPrediction.ts

@@ -131,7 +131,7 @@ function predictCallBase(config: {
         let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
         if (!result) return;
         if (result.lastInternalLoopCount === -1) return;
-        cleanupPrediction();
+        void cleanupPrediction();
         actualValueFinished.resolve();
         for (let callback of onPredictionFinishedCallbacks) {
             callback({ callId: call.CallId, result, functionId: call.FunctionId });
@@ -328,7 +328,7 @@ function predictCallBase(config: {
     }
 
     setTimeout(cleanupPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
-    function cleanupPrediction() {
+    async function cleanupPrediction() {
         if (didCancel) return;
 
         // ALWAYS reject the prediction, in case the function runner server is down.
@@ -338,7 +338,10 @@ function predictCallBase(config: {
         //      which create a memory leak.
         rejectPrediction();
 
+
         if (Querysub.AUDIT_PREDICTIONS && predictions) {
+            // Wait to receive all parts of the prediction
+            await delay(10_000);
             const afterTime = { time: call.runAtTime.time, version: Number.MAX_SAFE_INTEGER, creatorId: 0 };
             // Clone predictions, to strip symbols
             let predictionsCopy = cborEncoder().decode(cborEncoder().encode(predictions)) as typeof predictions;

package/src/deployManager/components/CommitModal.tsx

@@ -0,0 +1,274 @@
+import preact from "preact";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../../4-dom/qreact";
+import { css } from "../../4-dom/css";
+import { MachineServiceController } from "../machineSchema";
+import { Querysub } from "../../4-querysub/QuerysubController";
+import { InputLabel } from "../../library-components/InputLabel";
+import { DropdownSelector } from "../../library-components/DropdownSelector";
+import { closeAllModals } from "../../5-diagnostics/Modal";
+import { callOpenRouterModel, OpenRouterEffort } from "../../diagnostics/logs/errorNotifications2/openRouterHelper";
+import { formatNumber } from "socket-function/src/formatting/format";
+import { t } from "../../2-proxy/schema2";
+
+module.hotreload = true;
+
+// Models offered for AI commit-message summarization. These are exact OpenRouter
+//  model ids and are passed through to the API verbatim. The first is the default.
+export const SUGGEST_MODELS = [
+    "anthropic/claude-sonnet-4.6",
+    "google/gemini-3.1-flash-lite",
+    "qwen/qwen3.5-9b",
+    "~google/gemini-flash-latest",
+    "x-ai/grok-4.1-fast",
+    "nousresearch/hermes-3-llama-3.1-405b",
+    "google/gemini-3.1-pro-preview",
+    "anthropic/claude-opus-4.7",
+];
+
+const EFFORT_LEVELS: OpenRouterEffort[] = ["none", "low", "medium", "high"];
+
+// localStorage keys for persisting the user's OpenRouter preferences.
+const STORAGE_API_KEY = "commitSummary.openRouterApiKey";
+const STORAGE_MODEL = "commitSummary.model";
+const STORAGE_EFFORT = "commitSummary.effort";
+
+const DEFAULT_EFFORT: OpenRouterEffort = "low";
+
+const COMMIT_PROMPT = `You are an expert software engineer writing a git commit message.
+Summarize the following code changes into a clear, concise commit message.
+
+Rules:
+- The first line is a short summary in the imperative mood, max 72 characters.
+- If useful, add bullet points describing notable changes.
+- Output ONLY the raw commit message. No markdown code fences, no preamble, no quotes.
+
+Changes (git diff):
+{{DIFF}}`;
+
+const DEFAULT_MODEL = SUGGEST_MODELS[0];
+
+function loadStored(key: string, fallback: string): string {
+    if (typeof localStorage === "undefined") return fallback;
+    return localStorage.getItem(key) ?? fallback;
+}
+function saveStored(key: string, value: string) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(key, value);
+}
+
+/** Strips a surrounding markdown code fence, in case the model ignores the instruction. */
+function cleanCommitMessage(text: string): string {
+    text = text.trim();
+    let fenceMatch = text.match(/^```[^\n]*\n([\s\S]*?)\n```$/);
+    if (fenceMatch) {
+        text = fenceMatch[1].trim();
+    }
+    return text;
+}
+
+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;
+    /** 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>;
+}> {
+    state = t.state({
+        message: t.string,
+        apiKey: t.string(loadStored(STORAGE_API_KEY, "")),
+        model: t.string(loadStored(STORAGE_MODEL, DEFAULT_MODEL)),
+        effort: t.atomic(loadStored(STORAGE_EFFORT, DEFAULT_EFFORT) as OpenRouterEffort),
+        diff: t.string,
+        diffLoading: t.boolean(true),
+        summarizing: t.boolean(false),
+        committing: t.boolean(false),
+        error: t.string,
+        lastCost: t.number,
+    });
+
+    componentDidMount() {
+        Querysub.onCommitFinished(() => {
+            void this.loadDiff();
+        });
+    }
+
+    private async loadDiff() {
+        try {
+            let isQuerysub = Querysub.localRead(() => this.props.isQuerysub);
+            let controller = MachineServiceController(SocketFunction.browserNodeId());
+            let diff = await controller.getGitDiff.promise({ useQuerysub: isQuerysub });
+            Querysub.localCommit(() => {
+                this.state.diff = diff;
+                this.state.diffLoading = false;
+            });
+        } catch (e: any) {
+            Querysub.localCommit(() => {
+                this.state.error = `Failed to load changes: ${e.stack ?? e}`;
+                this.state.diffLoading = false;
+            });
+        }
+    }
+
+    private async doSummarize() {
+        let { apiKey, model, effort, diff } = Querysub.localRead(() => ({
+            apiKey: this.state.apiKey,
+            model: this.state.model,
+            effort: this.state.effort,
+            diff: this.state.diff,
+        }));
+        if (!apiKey.trim()) {
+            Querysub.localCommit(() => { this.state.error = "Enter an OpenRouter API key first."; });
+            return;
+        }
+        if (!diff) {
+            Querysub.localCommit(() => { this.state.error = "No changes available to summarize."; });
+            return;
+        }
+        Querysub.localCommit(() => {
+            this.state.summarizing = true;
+            this.state.error = "";
+        });
+        try {
+            let result = await callOpenRouterModel({
+                apiKey,
+                model,
+                effort,
+                prompt: COMMIT_PROMPT.replace("{{DIFF}}", diff),
+                onProgress: partial => {
+                    Querysub.localCommit(() => { this.state.message = partial; });
+                },
+            });
+            Querysub.localCommit(() => {
+                this.state.message = cleanCommitMessage(result.text);
+                this.state.lastCost = result.cost ?? 0;
+            });
+        } catch (e: any) {
+            Querysub.localCommit(() => { this.state.error = `Summarize failed: ${e.stack ?? e}`; });
+        } finally {
+            Querysub.localCommit(() => { this.state.summarizing = false; });
+        }
+    }
+
+    private async doCommit() {
+        let message = Querysub.localRead(() => this.state.message).trim();
+        if (!message) {
+            Querysub.localCommit(() => { this.state.error = "Commit message is empty."; });
+            return;
+        }
+        Querysub.localCommit(() => {
+            this.state.committing = true;
+            this.state.error = "";
+        });
+        try {
+            await this.props.onCommit(message);
+            closeAllModals();
+        } catch (e: any) {
+            Querysub.localCommit(() => {
+                this.state.error = `Commit failed: ${e.stack ?? e}`;
+                this.state.committing = false;
+            });
+        }
+    }
+
+    render() {
+        let { diff, diffLoading, summarizing, committing } = this.state;
+        let diffBytes = diff ? new TextEncoder().encode(diff).length : 0;
+
+        let summarizeLabel: string;
+        if (diffLoading) {
+            summarizeLabel = "Summarize (loading changes…)";
+        } else if (summarizing) {
+            summarizeLabel = "Summarizing…";
+        } else {
+            summarizeLabel = `Summarize ${diffBytes.toLocaleString()} bytes of changes`;
+        }
+
+        return <div className={css.vbox(12).minWidth(620)}>
+            <InputLabel
+                label="Commit message (shift+enter/shift+tab to commit, escape to cancel)"
+                value={this.state.message}
+                textarea
+                fillWidth
+                focusOnMount
+                hot
+                noEnterKeyCommit
+                alwaysUseLatestValueWhenFocused
+                style={{ height: 300 }}
+                onChangeValue={value => { this.state.message = value; }}
+                onKeyDown={e => {
+                    if (e.key === "Enter" && e.shiftKey || e.key === "Tab" && e.shiftKey) {
+                        e.preventDefault();
+                        void this.doCommit();
+                    }
+                }}
+            />
+
+            <div className={css.hbox(10).flexWrap("wrap").alignItems("flex-end")}>
+                <button
+                    className={rowButtonStyle.hsl(45, 80, 85)}
+                    disabled={diffLoading || summarizing}
+                    onClick={() => void this.doSummarize()}
+                >
+                    🤖 {summarizeLabel}
+                </button>
+                <DropdownSelector
+                    title="Model"
+                    value={this.state.model}
+                    onChange={value => {
+                        this.state.model = value;
+                        saveStored(STORAGE_MODEL, value);
+                    }}
+                    options={SUGGEST_MODELS.map(m => ({ value: m, label: m }))}
+                />
+                <DropdownSelector
+                    title="Thinking effort"
+                    value={this.state.effort}
+                    onChange={value => {
+                        this.state.effort = value;
+                        saveStored(STORAGE_EFFORT, value);
+                    }}
+                    options={EFFORT_LEVELS.map(level => ({ value: level, label: level }))}
+                />
+                {this.state.lastCost && <span className={css.colorhsl(0, 0, 45).fontSize(12)}>
+                    {formatNumber(1 / this.state.lastCost)} / USD
+                </span>}
+            </div>
+
+            <InputLabel
+                label="OpenRouter API Key"
+                value={this.state.apiKey}
+                type="password"
+                fillWidth
+                hot
+                onChangeValue={value => {
+                    this.state.apiKey = value;
+                    saveStored(STORAGE_API_KEY, value);
+                }}
+            />
+
+            {this.state.error && <div className={
+                css.pad2(10).bord2(0, 80, 50).hsl(0, 80, 95).colorhsl(0, 80, 30).whiteSpace("pre-wrap")
+            }>
+                ⚠️ {this.state.error}
+            </div>}
+
+            <div className={css.hbox(10)}>
+                <button
+                    className={rowButtonStyle.hsl(120, 70, 85)}
+                    disabled={committing}
+                    onClick={() => void this.doCommit()}
+                >
+                    {committing ? "Committing…" : "⬆️ Commit & Push"}
+                </button>
+            </div>
+
+            <div className={css.vbox(5)}>
+                {this.props.changes.map(change => <div>{change}</div>)}
+            </div>
+        </div>;
+    }
+}

package/src/deployManager/components/deployButtons.tsx

@@ -2,13 +2,12 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
 import { MachineServiceController, MachineInfo, ServiceConfig } from "../machineSchema";
 import { showFullscreenModal } from "../../5-diagnostics/FullscreenModal";
-import { InputLabel } from "../../library-components/InputLabel";
 import { css } from "../../4-dom/css";
 import { formatTime } from "socket-function/src/formatting/format";
 import { formatDateJSX } from "../../misc/formatJSX";
 import { MachineController } from "../machineController";
-import { closeAllModals } from "../../5-diagnostics/Modal";
 import { unique } from "../../misc";
+import { CommitModal } from "./CommitModal";
 
 module.hotreload = true;
 
@@ -56,32 +55,13 @@ export class UpdateButtons extends qreact.Component<{
                 title={gitInfo?.querysubUncommitted.join("\n")}
                 onClick={() => {
                     showFullscreenModal({
-                        content: <div>
-                            <InputLabel
-                                label="Commit message (shift+enter/shift+tab to commit, escape to cancel)"
-                                value={""}
-                                textarea
-                                fillWidth
-                                focusOnMount
-                                noEnterKeyCommit
-                                onKeyDown={async e => {
-                                    let value = e.currentTarget.value;
-                                    if (!value) return;
-                                    if (e.key === "Enter" && e.shiftKey || e.key === "Tab" && e.shiftKey) {
-                                        e.preventDefault();
-                                        await controller.commitPushAndPublishQuerysub.promise(value);
-                                        closeAllModals();
-                                    }
-                                }}
-                            />
-                            <div className={css.vbox(5)}>
-                                {gitInfo?.querysubUncommitted.map(change => {
-                                    return <div>
-                                        {change}
-                                    </div>;
-                                })}
-                            </div>
-                        </div>
+                        content: <CommitModal
+                            isQuerysub
+                            changes={gitInfo?.querysubUncommitted ?? []}
+                            onCommit={async message => {
+                                await controller.commitPushAndPublishQuerysub.promise(message);
+                            }}
+                        />
                     });
                 }}
             >
@@ -99,32 +79,12 @@ export class UpdateButtons extends qreact.Component<{
                 title={gitInfo?.uncommitted.join("\n")}
                 onClick={() => {
                     showFullscreenModal({
-                        content: <div>
-                            <InputLabel
-                                label="Commit message (shift+enter/shift+tab to commit, escape to cancel)"
-                                value={""}
-                                textarea
-                                fillWidth
-                                focusOnMount
-                                noEnterKeyCommit
-                                onKeyDown={async e => {
-                                    let value = e.currentTarget.value;
-                                    if (!value) return;
-                                    if (e.key === "Enter" && e.shiftKey || e.key === "Tab" && e.shiftKey) {
-                                        e.preventDefault();
-                                        await controller.commitPushService.promise(value);
-                                        closeAllModals();
-                                    }
-                                }}
-                            />
-                            <div className={css.vbox(5)}>
-                                {gitInfo?.uncommitted.map(change => {
-                                    return <div>
-                                        {change}
-                                    </div>;
-                                })}
-                            </div>
-                        </div>
+                        content: <CommitModal
+                            changes={gitInfo?.uncommitted ?? []}
+                            onCommit={async message => {
+                                await controller.commitPushService.promise(message);
+                            }}
+                        />
                     });
                 }}
             >

package/src/deployManager/machineApplyMainCode.ts

@@ -26,7 +26,12 @@ import { PromiseObj } from "../promise";
 import path from "path";
 import { fsExistsAsync } from "../fs";
 
-const PIPE_FILE_LINE_LIMIT = 10_000;
+// The deployed-service stdout log (pipe.txt) is a rolling buffer: once it grows
+// to PIPE_FILE_LINE_LIMIT lines it is truncated down to PIPE_FILE_LINE_KEEP. The
+// file size is checked every PIPE_FILE_LINE_KEEP lines, so the file stays within
+// [PIPE_FILE_LINE_KEEP, PIPE_FILE_LINE_LIMIT] lines.
+const PIPE_FILE_LINE_LIMIT = 2_000;
+const PIPE_FILE_LINE_KEEP = 1_000;
 
 
 const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ value: number; max: number } | undefined> {
@@ -551,16 +556,16 @@ while IFS= read -r line; do
     echo "$line" >> "${pipeFile}"
     ((line_count++))
     
-    # Check line count every ${PIPE_FILE_LINE_LIMIT} lines to avoid too much overhead
-    if (( line_count % ${PIPE_FILE_LINE_LIMIT} == 0 )); then
+    # Check line count every ${PIPE_FILE_LINE_KEEP} lines to avoid too much overhead
+    if (( line_count % ${PIPE_FILE_LINE_KEEP} == 0 )); then
         if [ -f "${pipeFile}" ]; then
             # Count total lines in file
             total_lines=$(wc -l < "${pipeFile}")
-            if [ "$total_lines" -gt ${PIPE_FILE_LINE_LIMIT} ]; then
+            if [ "$total_lines" -ge ${PIPE_FILE_LINE_LIMIT} ]; then
                 # Wait 2 seconds to give the watcher time to read pending content
                 sleep 2
-                # Keep only the last ${PIPE_FILE_LINE_LIMIT} lines when file gets too many lines
-                tail -n ${Math.floor(PIPE_FILE_LINE_LIMIT / 2)} "${pipeFile}" > "${pipeFile}.tmp" && mv "${pipeFile}.tmp" "${pipeFile}"
+                # Keep only the last ${PIPE_FILE_LINE_KEEP} lines when file gets too many lines
+                tail -n ${PIPE_FILE_LINE_KEEP} "${pipeFile}" > "${pipeFile}.tmp" && mv "${pipeFile}.tmp" "${pipeFile}"
                 # AND, give it time to read the truncation
                 sleep 2
             fi