querysub 0.502.0 → 0.504.0

package/package.json

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

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

@@ -177,7 +177,7 @@ let moduleResolver = async (spec: {
             await executeCommand("git", ["reset", "--hard", spec.gitRef], { cwd: repoPath });
 
             // Yarn install
-            await executeCommand("yarn", ["install"], { cwd: repoPath });
+            await yarnInstallWithHealing(repoPath);
 
             // Delete querysub, and replace it with a symlink. Otherwise the synchronization code
             //  will run again, and a lot of setup code will run again, etc, and nothing will work correctly.
@@ -462,6 +462,22 @@ const hotreloadIfChanged = batchFunction({ delay: 100, name: "hotreloadIfChanged
     }
 });
 
+// A corrupt entry in the shared global yarn cache (e.g. "Extracting tar content ... the file appears to be
+//  corrupt") fails every install identically, because re-cloning the repo folder never touches the global
+//  cache. Detect that, purge the cache with `yarn cache clean`, and retry once so the loader heals itself.
+async function yarnInstallWithHealing(repoPath: string): Promise<void> {
+    try {
+        await executeCommand("yarn", ["install", "--mutex", "network"], { cwd: repoPath });
+        return;
+    } catch (e) {
+        let errorText = String((e as Error)?.stack || e);
+        if (!/appears to be corrupt|Extracting tar content/.test(errorText)) throw e;
+        console.log(red(`yarn install failed with a corrupt yarn cache, cleaning cache and retrying:\n${errorText}`));
+        await executeCommand("yarn", ["cache", "clean"]);
+    }
+    await executeCommand("yarn", ["install", "--mutex", "network"], { cwd: repoPath });
+}
+
 async function which(command: string): Promise<string> {
     let whichOrWhere = os.platform() === "win32" ? "where" : "which";
     let path = child_process.execSync(`${whichOrWhere} ${command}`).toString().trim().replaceAll("\r", "").split("\n")[0].trim().replaceAll("\\", "/");

package/src/deployManager/machineApplyMainCode.ts

@@ -743,7 +743,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     let nodeModulesMissing = !await fsExistsAsync(gitFolder + "node_modules");
                     if (afterGitRef !== prevGitRef || nodeModulesMissing) {
                         console.log(green(`Yarn installing for ${magenta(screenName)} (ref ${prevGitRef} -> ${afterGitRef}, nodeModulesMissing=${nodeModulesMissing})`));
-                        await runPromise(`yarn install`, { cwd: gitFolder });
+                        await runPromise(`yarn install --mutex network`, { cwd: gitFolder });
                     }
                 }
                 let parameterPath = folder + "/parameters.json";

package/src/deployManager/machineController.ts

@@ -136,7 +136,7 @@ class MachineControllerBase {
             gitFolder,
             gitRef: config.gitRef,
         });
-        await runPromise("yarn install", { cwd: gitFolder });
+        await runPromise("yarn install --mutex network", { cwd: gitFolder });
         await runPromise("bash machine-startup.sh", { cwd: os.homedir(), detach: true });
     }
 

package/src/diagnostics/logs/errorTickets/TicketPage.tsx

@@ -9,6 +9,7 @@ import { Querysub } from "../../../4-querysub/Querysub";
 import { URLParam } from "../../../library-components/URLParam";
 import { ATag } from "../../../library-components/ATag";
 import { Button } from "../../../library-components/Button";
+import { InputLabel } from "../../../library-components/InputLabel";
 import { LogDatum } from "../diskLogger";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { TicketsController, watchTickets } from "./tickets";
@@ -183,6 +184,11 @@ export class TicketPage extends qreact.Component {
 }
 
 class TicketList extends qreact.Component {
+    state = t.state({
+        newTicketTitle: t.atomic<string>(""),
+        newTicketText: t.atomic<string>(""),
+    });
+
     render() {
         let tickets = getController().getTickets();
         if (!tickets) {
@@ -216,6 +222,65 @@ class TicketList extends qreact.Component {
                 <code className={css.pad2(8, 4).hsl(220, 15, 15).colorhsl(120, 60, 70).fontSize(13).borderRadius(3)}>yarn autofix</code>
                 <span>to automatically investigate and fix open tickets.</span>
             </div>
+            <div className={css.vbox(8).pad2(12).bord2(210, 50, 60).hsl(210, 50, 96).fillWidth}>
+                <strong>Create Custom Ticket</strong>
+                <InputLabel
+                    label="Title"
+                    className={css.width(600)}
+                    value={this.state.newTicketTitle}
+                    onChangeValue={(value) => {
+                        this.state.newTicketTitle = value;
+                    }}
+                />
+                <textarea
+                    className={css.minHeight(COMMENT_TEXTAREA_COLLAPSED_HEIGHT).minHeight(COMMENT_TEXTAREA_MIN_HEIGHT, "focus").fillWidth.pad2(8).fontSize(14).resize("vertical")}
+                    value={this.state.newTicketText}
+                    onInput={e => {
+                        this.state.newTicketText = (e.target as HTMLTextAreaElement).value;
+                    }}
+                />
+                <div className={css.hbox(8)}>
+                    <Button
+                        hue={210}
+                        onClick={() => {
+                            let title = this.state.newTicketTitle.trim();
+                            let text = this.state.newTicketText.trim();
+                            if (!title) return;
+                            Querysub.onCommitFinished(async () => {
+                                let now = Date.now();
+                                let ticket: Ticket = {
+                                    id: nextId(),
+                                    title: title.slice(0, TITLE_MAX_LENGTH),
+                                    state: "investigation",
+                                    createdTime: now,
+                                    lastUpdatedTime: now,
+                                    errorDatum: {
+                                        time: now,
+                                        __LOG_TYPE: "custom",
+                                        param0: title,
+                                    },
+                                    comments: !text && [] || [{
+                                        id: nextId(),
+                                        time: now,
+                                        author: "user",
+                                        kind: "text" as const,
+                                        text,
+                                    }],
+                                };
+                                await getController().createTicket.promise(ticket);
+                                resetTicketData();
+                                Querysub.commit(() => {
+                                    this.state.newTicketTitle = "";
+                                    this.state.newTicketText = "";
+                                    goToTicket(ticket.id);
+                                });
+                            });
+                        }}
+                    >
+                        Create Ticket
+                    </Button>
+                </div>
+            </div>
             {sorted.length === 0 && <div>No tickets. Create one from the Error Notifications page with the "Ticket" button.</div>}
             <div className={css.vbox(8).fillWidth.flexGrow(1).minHeight(0).overflowAuto}>
                 {sorted.map(ticket => (

package/src/diagnostics/logs/errorTickets/autoFixer.ts

@@ -161,39 +161,61 @@ async function registerWithTicketService() {
     }
 }
 
-async function applyPatch(ticketId: string, commentId: string): Promise<void> {
-    let service = await ticketService();
-    let ticket = await service.getTicket(ticketId);
-    if (!ticket) {
-        throw new Error(`Ticket ${ticketId} not found`);
-    }
-    let comment = ticket.comments.find(c => c.id === commentId);
-    if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
-        throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
+// Relative paths may belong to either the application repo or the querysub repo (a sibling / dependency) — file paths are unique across the two, so whichever one actually has the file wins.
+function resolvePatchFilePath(file: string): { fullPath: string | undefined; candidates: string[] } {
+    let candidates = Array.from(new Set([
+        path.resolve(process.cwd(), file),
+        path.resolve(QUERYSUB_ROOT, file),
+    ]));
+    for (let candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return { fullPath: candidate, candidates };
+        }
     }
+    return { fullPath: undefined, candidates };
+}
 
-    // Validate everything before writing anything, so a patch is all-or-nothing.
+// Resolves and validates every file entry without writing anything (so a patch is all-or-nothing), returning the writes to perform. Throws with a detailed message when the patch cannot apply cleanly — also used at addPatch time so the AI is told about mistakes immediately.
+function preparePatchWrites(patchFiles: TicketPatchFile[]): { fullPath: string; newContents: string }[] {
     let writes: { fullPath: string; newContents: string }[] = [];
-    for (let patchFile of comment.patchFiles) {
-        let fullPath = path.resolve(process.cwd(), patchFile.file);
+    for (let patchFile of patchFiles) {
+        let { fullPath, candidates } = resolvePatchFilePath(patchFile.file);
         if (!patchFile.oldText) {
-            if (fs.existsSync(fullPath) && fs.readFileSync(fullPath, "utf8").trim()) {
-                throw new Error(`Patch wants to create ${patchFile.file}, but it already exists and is not empty`);
+            if (fullPath && fs.readFileSync(fullPath, "utf8").trim()) {
+                throw new Error(`Patch wants to create ${patchFile.file}, but it already exists at ${fullPath} and is not empty`);
             }
-            writes.push({ fullPath, newContents: patchFile.newText });
+            writes.push({ fullPath: fullPath ?? candidates[0], newContents: patchFile.newText });
             continue;
         }
-        if (!fs.existsSync(fullPath)) {
-            throw new Error(`Patch targets ${patchFile.file}, which does not exist (cwd is ${process.cwd()})`);
+        if (!fullPath) {
+            throw new Error(`Patch targets ${patchFile.file}, which does not exist. Tried: ${candidates.join(", ")}`);
         }
         let contents = fs.readFileSync(fullPath, "utf8");
         let index = contents.indexOf(patchFile.oldText);
         if (index === -1) {
-            throw new Error(`Patch oldText not found in ${patchFile.file}. The file may have changed since the patch was created.`);
+            throw new Error(`Patch oldText not found in ${fullPath}. oldText must be copied EXACTLY from the current file contents (check whitespace/indentation).`);
+        }
+        if (contents.indexOf(patchFile.oldText, index + 1) !== -1) {
+            throw new Error(`Patch oldText appears more than once in ${fullPath}, so the replacement is ambiguous. Include more surrounding context to make it unique.`);
         }
         let newContents = contents.slice(0, index) + patchFile.newText + contents.slice(index + patchFile.oldText.length);
         writes.push({ fullPath, newContents });
     }
+    return writes;
+}
+
+async function applyPatch(ticketId: string, commentId: string): Promise<void> {
+    let service = await ticketService();
+    let ticket = await service.getTicket(ticketId);
+    if (!ticket) {
+        throw new Error(`Ticket ${ticketId} not found`);
+    }
+    let comment = ticket.comments.find(c => c.id === commentId);
+    if (!comment || comment.kind !== "patch" || !comment.patchFiles) {
+        throw new Error(`Comment ${commentId} is not a patch comment on ticket ${ticketId}`);
+    }
+
+    let writes = preparePatchWrites(comment.patchFiles);
     for (let write of writes) {
         fs.mkdirSync(path.dirname(write.fullPath), { recursive: true });
         fs.writeFileSync(write.fullPath, write.newContents);
@@ -258,7 +280,7 @@ Query syntax (case-insensitive substring match by default):
     },
     {
         name: "addPatch",
-        description: `Propose a code patch on the ticket. The patch is NOT applied automatically — a human reviews it and applies or rejects it. Each file entry replaces the first exact occurrence of oldText with newText. oldText must be copied exactly from the current file contents and should be unique within the file. An empty oldText creates a new file with newText as its contents.`,
+        description: `Propose a code patch on the ticket. The patch is NOT applied automatically — a human reviews it and applies or rejects it. Each file entry replaces the exact occurrence of oldText with newText. oldText must be copied exactly from the current file contents and must be unique within the file. An empty oldText creates a new file with newText as its contents. The patch is validated against the current files when you submit it — if validation fails you get an error explaining why and the patch is not added; fix it and resubmit.`,
         inputSchema: {
             type: "object",
             properties: {
@@ -359,6 +381,11 @@ async function callTool(toolName: string, args: Record<string, unknown>): Promis
                 throw new Error(`Each patch file entry requires file, oldText, and newText`);
             }
         }
+        try {
+            preparePatchWrites(files);
+        } catch (e) {
+            throw new Error(`Patch validation failed — the patch was NOT added. Fix the problem and call addPatch again. ${(e as Error).message}`);
+        }
         await addTicketComment(ticketId, {
             kind: "patch",
             text,
@@ -532,7 +559,7 @@ PHASE 2 — FIX. Only after you have added your diagnosis comment, decide on the
   1. Downgrading logging: when the "error" is not actually an error, patch the logging call site to downgrade it from an error to a warning or a plain log, so it stops being reported.
   2. Actually fixing the broken code.
   3. Gathering more information: if you could NOT determine the root cause from the available logs, propose patches that ADD logging statements to the relevant code paths so the next investigation has the information it needs.
-Each patch file entry is { file, oldText, newText }: oldText must be copied exactly from the current file contents and should be unique within the file; it is replaced with newText. An empty oldText creates a new file. Relative file paths are resolved against the application repository (${process.cwd()}); for files in the querysub repository use absolute paths. Keep patches minimal and follow the style of the surrounding code.
+Each patch file entry is { file, oldText, newText }: oldText must be copied exactly from the current file contents and should be unique within the file; it is replaced with newText. An empty oldText creates a new file. Relative file paths are resolved against the application repository (${process.cwd()}) first, then against the querysub repository (${QUERYSUB_ROOT}) — whichever contains the file. Absolute paths also work. Keep patches minimal and follow the style of the surrounding code.
 
 When you are done, call mcp__autofixer__setTicketState with "code-change" if you proposed patches, or "not-a-bug" if the error should simply be ignored without any code change. If you are confused and just cannot figure out what is going on — the logs and code don't add up, and you can't even propose useful additional logging — add a comment explaining what you tried and what confused you, then call mcp__autofixer__setTicketState with "confused". Do NOT edit files directly — only propose changes through mcp__autofixer__addPatch.
 
@@ -558,6 +585,21 @@ const QUERYSUB_ROOT = path.resolve(__dirname, "../../../..");
 // Set for the duration of a claude run; called whenever a turn finishes (a stream-json "result" event), so the run loop can decide to forward new user comments or end the session.
 let claudeTurnEndedHandler: (() => void) | undefined = undefined;
 
+// Built-in tools (Read/Glob/Grep) don't go through our MCP server, so we record them from the stream instead: tool_use blocks are stashed here until their tool_result arrives in a "user" event. Our own mcp__autofixer__ tools are excluded — callTool already records those.
+let pendingStreamToolCalls = new Map<string, { name: string; input: string; startTime: number }>();
+
+function toolResultToText(content: unknown): string {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+        return content.map(block =>
+            block && typeof block === "object" && (block as { type?: string; text?: string }).type === "text"
+                ? String((block as { text?: string }).text ?? "")
+                : JSON.stringify(block)
+        ).join("\n");
+    }
+    return JSON.stringify(content);
+}
+
 type ClaudeUsage = {
     input_tokens?: number;
     cache_creation_input_tokens?: number;
@@ -594,6 +636,13 @@ function handleClaudeStreamLine(line: string): boolean {
                 console.log(`[claude] ${String(block.text).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
             } else if (block.type === "tool_use") {
                 console.log(`[claude] tool_use: ${blue(String(block.name))} ${JSON.stringify(block.input ?? {}).slice(0, CLAUDE_LOG_PREVIEW_CHARS)}`);
+                if (block.id && !String(block.name).startsWith("mcp__autofixer__")) {
+                    pendingStreamToolCalls.set(String(block.id), {
+                        name: String(block.name),
+                        input: JSON.stringify(block.input ?? {}),
+                        startTime: Date.now(),
+                    });
+                }
             }
         }
         return true;
@@ -607,8 +656,37 @@ function handleClaudeStreamLine(line: string): boolean {
         claudeTurnEndedHandler?.();
         return true;
     }
-    if (event.type === "system" || event.type === "user") {
-        // Init/config noise and tool results (which we already record in the ticket).
+    if (event.type === "user") {
+        // Tool results for built-in tools — record them in the ticket like our own tool calls.
+        for (let block of event.message?.content ?? []) {
+            if (block?.type !== "tool_result" || !block.tool_use_id) continue;
+            let pending = pendingStreamToolCalls.get(String(block.tool_use_id));
+            if (!pending) continue;
+            pendingStreamToolCalls.delete(String(block.tool_use_id));
+            let ticketId = currentTicketId;
+            if (!ticketId) continue;
+            let outputText = toolResultToText(block.content);
+            if (block.is_error) {
+                outputText = `ERROR: ${outputText}`;
+            }
+            if (outputText.length > MAX_TOOL_OUTPUT_STORED) {
+                outputText = outputText.slice(0, MAX_TOOL_OUTPUT_STORED) + `... (truncated, ${outputText.length} chars total)`;
+            }
+            addTicketComment(ticketId, {
+                kind: "tool-call",
+                text: "",
+                toolName: pending.name,
+                toolInput: pending.input,
+                toolOutput: outputText,
+                toolDurationMs: Date.now() - pending.startTime,
+            }).catch(e => {
+                console.error(`Failed to record tool call in ticket ${ticketId}:`, (e as Error).stack ?? e);
+            });
+        }
+        return true;
+    }
+    if (event.type === "system") {
+        // Init/config noise.
         return true;
     }
     return false;
@@ -745,6 +823,7 @@ async function runInvestigation(ticket: Ticket): Promise<void> {
     currentTicketTitle = ticket.title;
     currentTicketStartTime = Date.now();
     runTokens = emptyTokens();
+    pendingStreamToolCalls.clear();
     stateChangedDuringRun = false;
     patchAddedDuringRun = false;
     try {