codeloop-mcp-server 0.1.56 → 0.1.60

package/dist/index.js

@@ -174,6 +174,35 @@ startUpdateCheck();
  * issues we've already written to disk continue to gate ready_for_review.
  */
 const modalPersistenceTracker = new Map();
+/**
+ * 0.1.57 H2 — Throttle for the post-interact modal probe.
+ *
+ * 0.1.55 only ran the probe after SUCCESSFUL clicky/escape actions, so a
+ * file dialog that blocked the app (subsequent clicks fail, or the agent
+ * switches to wait / capture_screenshot / win_ui_automate) was never
+ * re-detected and the persistence counter never climbed — the modal sat
+ * open with zero cycle issues recorded (E2E #12). We now probe on the
+ * broader modal-related action set REGARDLESS of success, and use this map
+ * to keep the PowerShell cost bounded: clicky/escape always probe; other
+ * modal-related actions probe at most once per throttle window per app.
+ */
+const modalProbeLastAt = new Map();
+const MODAL_PROBE_THROTTLE_MS = 1500;
+/**
+ * 0.1.57 H3 — auto-close stuck external file dialogs.
+ *
+ * Default ON. The user can opt out per-machine with
+ * CODELOOP_AUTO_CLOSE_STUCK_MODALS=0 (or "false"/"off") if a workflow
+ * legitimately keeps a file picker open across many interactions.
+ */
+function autoCloseStuckModalsEnabled() {
+    const v = (process.env.CODELOOP_AUTO_CLOSE_STUCK_MODALS ?? "").trim().toLowerCase();
+    if (v === "0" || v === "false" || v === "off" || v === "no")
+        return false;
+    return true;
+}
+/** Consecutive same-dialog detections that mark a file dialog as genuinely stuck. */
+const MODAL_AUTOCLOSE_THRESHOLD = 3;
 const server = new McpServer({
     name: "codeloop",
     version: "0.1.14",
@@ -1924,6 +1953,59 @@ After stopping, call codeloop_interaction_replay with the run_id to extract fram
 The response includes log_path if app logs were captured during the recording session.`, {
     recording_id: z.string().describe("The recording_id returned by codeloop_start_recording"),
 }, async (params) => {
+    // 0.1.57 H4 — stuck-modal sweep. If a file dialog is still open when the
+    // recording stops (E2E #12: the external folder picker that "kept opening
+    // all the time"), close it automatically so it does not linger on the
+    // user's desktop after the cycle. Best-effort and Windows-only; never
+    // blocks the stop. Runs BEFORE finalising so the close is visible in the
+    // final frames.
+    let sweepNote;
+    if (process.platform === "win32" && autoCloseStuckModalsEnabled()) {
+        try {
+            const { detectModal } = await import("./runners/modal_detector.js");
+            const { closeModalWithStrategies } = await import("./runners/modal_close_strategies.js");
+            const vrMod = await import("./runners/video_recorder.js");
+            const appNameForModal = vrMod.getActiveRecordingAppName() || undefined;
+            const detection = await detectModal({
+                target_type: "desktop",
+                app_name: appNameForModal,
+                cwd: projectDir,
+            });
+            if (detection.is_modal_present && detection.modal_kind === "file_dialog") {
+                const closeResult = await closeModalWithStrategies({
+                    initial_detection: detection,
+                    app_name: appNameForModal,
+                    cwd: projectDir,
+                });
+                const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
+                if (closeResult.closed) {
+                    const usedStrategy = closeResult.strategies_tried.find((s) => s.success)?.strategy ?? "ladder";
+                    sweepNote = `CodeLoop auto-closed a lingering file dialog (${detection.modal_description ?? "(unnamed)"}) at stop via ${usedStrategy}.`;
+                    await recordCycleIssue(projectDir, {
+                        kind: "modal_close_failed",
+                        modal_kind: detection.modal_kind ?? "file_dialog",
+                        modal_description: `${detection.modal_description ?? "(unnamed)"} (auto-closed by CodeLoop H4 stop sweep via ${usedStrategy})`,
+                        strategies_tried: closeResult.strategies_tried.filter((s) => s.success).map((s) => s.strategy),
+                        hwnd: detection.hwnd,
+                        auto_resolved: true,
+                    });
+                }
+                else {
+                    sweepNote = `A file dialog (${detection.modal_description ?? "(unnamed)"}) was still open at stop and the close ladder failed — call codeloop_kill_modal_window with hwnd ${detection.hwnd ?? "(see logs)"}.`;
+                    await recordCycleIssue(projectDir, {
+                        kind: "modal_close_failed",
+                        modal_kind: detection.modal_kind ?? "file_dialog",
+                        modal_description: detection.modal_description,
+                        strategies_tried: closeResult.strategies_tried.map((s) => s.strategy),
+                        hwnd: detection.hwnd ?? closeResult.hwnd,
+                    });
+                }
+            }
+        }
+        catch {
+            /* best-effort sweep — never block the stop */
+        }
+    }
     const authResult = await withAuth(async () => {
         const { stopBackgroundRecording } = await import("./runners/video_recorder.js");
         return stopBackgroundRecording(params.recording_id);
@@ -1945,6 +2027,7 @@ The response includes log_path if app logs were captured during the recording se
         "  1. codeloop_interaction_replay — extract frames + app logs from the just-saved video. This populates the data the replay/journey gates score against.",
         "  2. codeloop_gate_check — confirm confidence ≥ 94%. If continue_fixing, fix the failing gate's next_step and re-record / re-capture.",
         "Do NOT skip step 1 — without replay frames the interaction_replay_evidence gate fails even when the video exists. Do NOT pause to ask the user 'should I run replay now?' — yes, always.",
+        ...(sweepNote ? ["", `[CodeLoop H4] ${sweepNote}`] : []),
     ].join("\n");
     return {
         content: withInitHint([{ type: "text", text: JSON.stringify(result, null, 2) + nextStepDirective }]),
@@ -2166,6 +2249,36 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
                     .slice(0, 5)
                     .map((i) => `(${i.kind}) ${summariseCycleIssue(i)}`)
                     .join(" | ")}${ci.issues.length > 5 ? " | … (see logs/cycle_issues.jsonl for the full list)" : ""}`;
+        // 0.1.58-0.1.60 — Deep Internal Verification aggregate. Pull the most
+        // recent run that produced each evidence file so the dev report can
+        // document static analysis, changed-line coverage, backend smoke,
+        // API contract, DB schema, and runtime-log cleanliness.
+        const { loadCodeQualityEvidence } = await import("./evidence/deep_internal.js");
+        const { loadBackendVerification } = await import("./evidence/backend_verification.js");
+        const { loadRuntimeLogScan } = await import("./evidence/runtime_log_scan.js");
+        const deepInternal = { static_analysis: null, coverage: null, backend: null, runtime_log: null };
+        for (const runId of [...runs].reverse()) {
+            const runDir = getRunDir(runId, baseDir);
+            if (deepInternal.static_analysis === null || deepInternal.coverage === null) {
+                const cq = loadCodeQualityEvidence(runDir);
+                if (cq) {
+                    if (deepInternal.static_analysis === null)
+                        deepInternal.static_analysis = cq.static_analysis;
+                    if (deepInternal.coverage === null)
+                        deepInternal.coverage = cq.coverage;
+                }
+            }
+            if (deepInternal.backend === null) {
+                const b = loadBackendVerification(runDir);
+                if (b)
+                    deepInternal.backend = b;
+            }
+            if (deepInternal.runtime_log === null) {
+                const s = loadRuntimeLogScan(runDir);
+                if (s)
+                    deepInternal.runtime_log = s;
+            }
+        }
         const report = {
             project_name: params.project_name,
             project_description: params.project_description || "",
@@ -2190,6 +2303,7 @@ The agent MUST then write the report to docs/DEVELOPMENT_LOG.md and present it t
             cycle_issues_summary: cycleSummary,
             cycle_issues: cycleIssuesEntries,
             cycle_issues_directive: cycleIssuesDirective,
+            deep_internal_verification: deepInternal,
         };
         await trackUsage(apiKey, "verification_run");
         return report;
@@ -2255,6 +2369,19 @@ For EACH video recording session, document:
 Create a table with: | # | Bug Description | Severity | How Found | Fix Applied |
 List every issue discovered by CodeLoop during the development process.
 
+**7b. Deep Internal Verification** (0.1.58+)
+Document the internal (code / backend / terminal) verification evidence from the
+\`deep_internal_verification\` block above. Include a table:
+| Layer | Check | Result | Gate |
+|-------|-------|--------|------|
+| Static analysis | tsc / eslint / ruff / mypy / clippy / dotnet-format / flutter analyze | errors found / clean / n/a | static_analysis_passes |
+| Coverage | changed-line coverage % (covered/total) | pass / below threshold / n/a | code_coverage_threshold |
+| Backend smoke | health + route probes, 5xx count | healthy / failed / n/a | backend_smoke_evidence |
+| API contract | OpenAPI route conformance (violations) | pass / violations / n/a | api_contract_evidence |
+| DB schema | migration apply + drift | clean / drift / n/a | db_schema_evidence |
+| Runtime logs | exceptions / 5xx / fatal lines in logs | clean / errors / n/a | runtime_log_clean_evidence |
+State clearly which checks were applicable for this project's stack and which were n/a.
+
 **8. Cross-Platform Coverage**
 Document which OS and platform combinations CodeLoop supports:
 | OS | App Type | Video Method | Interaction Method | Log Capture |
@@ -3538,15 +3665,40 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         const isClosingIntent = /\b(close|dismiss|cancel|escape|exit)\b/.test(closingIntent);
         const isClickyAction = action === "click" || action === "double_click" || action === "right_click";
         const isEscapeKeystroke = action === "keystroke" && (params.key ?? "").toLowerCase() === "escape";
-        const shouldVerifyClickEffect = success && tt === "desktop" && (isClickyAction || isEscapeKeystroke);
-        if (shouldVerifyClickEffect) {
+        // 0.1.57 H2 — probe on the broader modal-related action set REGARDLESS
+        // of success. A blocked / failed click against a stuck file dialog is
+        // itself the signal we need (E2E #12: subsequent clicks failed, so the
+        // 0.1.55 `success &&` gate never re-ran the probe and the picker stayed
+        // open with zero cycle issues). Clicky/escape always probe; the wider
+        // set (type/hotkey/win_ui_automate/sequence/wait) probes at most once
+        // per throttle window so the PowerShell cost stays bounded.
+        const trackerKey = (params.app_name || vr.getActiveRecordingAppName() || "<default>").toLowerCase();
+        const clicky = isClickyAction || isEscapeKeystroke;
+        const widerModalActions = new Set([
+            "type",
+            "type_and_submit",
+            "type_and_tab",
+            "keystroke",
+            "hotkey",
+            "win_ui_automate",
+            "sequence",
+            "wait",
+            "hover",
+        ]);
+        const nowMs = Date.now();
+        const lastProbeMs = modalProbeLastAt.get(trackerKey) ?? 0;
+        const throttleOk = clicky || (widerModalActions.has(action) && nowMs - lastProbeMs > MODAL_PROBE_THROTTLE_MS);
+        const shouldCheckModal = tt === "desktop" && throttleOk;
+        if (shouldCheckModal) {
             try {
+                modalProbeLastAt.set(trackerKey, nowMs);
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 const { detectModal } = await import("./runners/modal_detector.js");
-                const trackerKey = (params.app_name || vr.getActiveRecordingAppName() || "<default>").toLowerCase();
+                const { closeModalWithStrategies } = await import("./runners/modal_close_strategies.js");
+                const appNameForModal = params.app_name || vr.getActiveRecordingAppName() || undefined;
                 const detection = await detectModal({
                     target_type: "desktop",
-                    app_name: params.app_name || vr.getActiveRecordingAppName() || undefined,
+                    app_name: appNameForModal,
                     cwd,
                 });
                 const { recordCycleIssue } = await import("./evidence/cycle_issues.js");
@@ -3605,11 +3757,79 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                             modal_kind: detection.modal_kind,
                         });
                     }
-                    // 0.1.55 F3 — at 3+ consecutive persistences, treat the modal
-                    // as actively stuck and write a modal_close_failed entry so
-                    // the cycle_issues_acknowledged gate fails even when the
-                    // agent never called codeloop_handle_modal.
-                    if (consecutive >= 3) {
+                    // 0.1.57 H3 — AUTOMATIC close of stuck external file dialogs.
+                    //
+                    // E2E #12: the agent rationalised a recurring OpenFolderDialog as
+                    // a "test artifact" and NEVER called codeloop_handle_modal, so the
+                    // picker was left open and kept reopening. CodeLoop must close it
+                    // itself rather than only directing the agent.
+                    //
+                    // Trigger conditions (all required) keep this safe against legit
+                    // picker usage:
+                    //   - it's a file_dialog (external OS picker — the exact class the
+                    //     user reports; confirm/alert kinds may need a real decision
+                    //     and are intentionally left to the agent),
+                    //   - it has persisted across >= MODAL_AUTOCLOSE_THRESHOLD (3)
+                    //     consecutive detections of the SAME dialog. A legitimate
+                    //     open→confirm picker flow clears within 1-2 interactions and
+                    //     resets the tracker, so reaching 3 means the agent is stuck.
+                    const isStuckFileDialog = detection.modal_kind === "file_dialog" &&
+                        consecutive >= MODAL_AUTOCLOSE_THRESHOLD;
+                    let autoClosed = false;
+                    if (isStuckFileDialog && autoCloseStuckModalsEnabled()) {
+                        try {
+                            const closeResult = await closeModalWithStrategies({
+                                initial_detection: detection,
+                                app_name: appNameForModal,
+                                cwd,
+                            });
+                            autoClosed = closeResult.closed;
+                            if (autoClosed) {
+                                modalPersistenceTracker.delete(trackerKey);
+                                const usedStrategy = closeResult.strategies_tried.find((s) => s.success)?.strategy ?? "ladder";
+                                detail = `${detail} | CodeLoop auto-closed stuck file dialog (${desc}) via ${usedStrategy}`;
+                                clickEffectVerification = {
+                                    ...(clickEffectVerification ?? { intent: closingIntent, modal_still_present: false }),
+                                    modal_still_present: false,
+                                    modal_description: detection.modal_description,
+                                    modal_kind: detection.modal_kind,
+                                    consecutive_persistences: consecutive,
+                                };
+                                // Surface the auto-handling so the dev report shows it was
+                                // caught and resolved (not silently swallowed).
+                                await recordCycleIssue(cwd, {
+                                    kind: "modal_close_failed",
+                                    modal_kind: detection.modal_kind ?? "file_dialog",
+                                    modal_description: `${desc} (auto-closed by CodeLoop H3 after ${consecutive} consecutive detections via ${usedStrategy})`,
+                                    strategies_tried: closeResult.strategies_tried
+                                        .filter((s) => s.success)
+                                        .map((s) => s.strategy),
+                                    hwnd: detection.hwnd,
+                                    auto_resolved: true,
+                                });
+                            }
+                            else {
+                                // Ladder exhausted — record the unresolved failure and
+                                // escalate the directive to kill-window.
+                                await recordCycleIssue(cwd, {
+                                    kind: "modal_close_failed",
+                                    modal_kind: detection.modal_kind ?? "file_dialog",
+                                    modal_description: desc,
+                                    strategies_tried: closeResult.strategies_tried.map((s) => s.strategy),
+                                    hwnd: detection.hwnd ?? closeResult.hwnd,
+                                });
+                            }
+                        }
+                        catch {
+                            /* best-effort auto-close; fall through to the F3/F4 path */
+                        }
+                    }
+                    // 0.1.55 F3 — at 3+ consecutive persistences, treat the modal as
+                    // actively stuck and write a modal_close_failed entry so the
+                    // cycle_issues_acknowledged gate fails even when the agent never
+                    // called codeloop_handle_modal. Skipped when H3 already recorded
+                    // the (auto-resolved or unresolved) outcome above.
+                    if (consecutive >= 3 && !isStuckFileDialog) {
                         await recordCycleIssue(cwd, {
                             kind: "modal_close_failed",
                             modal_kind: detection.modal_kind ?? "custom",
@@ -3620,14 +3840,20 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                             hwnd: detection.hwnd,
                         });
                     }
-                    // 0.1.55 F4 — HARD directive for the post-interact postscript.
-                    modalPersistenceDirective =
-                        `\n\n[CodeLoop F4] HARD: A ${detection.modal_kind ?? "modal"} dialog (${desc}) is STILL present after this interaction ` +
-                            `(${consecutive} consecutive interactions have not cleared it). ` +
-                            `Stop sending raw clicks / Escape keystrokes against it and call codeloop_handle_modal with decision: "cancel" or "dismiss" — ` +
-                            `the multi-strategy ladder (Escape → Alt+F4 → UIA Invoke "Close" → EndDialog) handles file dialogs the keystroke path cannot. ` +
-                            `If codeloop_handle_modal returns escalation: "kill_window_required", call codeloop_kill_modal_window with the returned hwnd. ` +
-                            `Continuing to ignore this modal will fail the cycle_issues_acknowledged gate and block ready_for_review.`;
+                    // 0.1.55 F4 / 0.1.57 H3 — HARD directive for the post-interact
+                    // postscript. Suppressed when CodeLoop already auto-closed the
+                    // dialog; otherwise escalated to kill-window when an auto-close
+                    // attempt was made and failed.
+                    if (!autoClosed) {
+                        const killHint = isStuckFileDialog
+                            ? `CodeLoop already attempted the multi-strategy close ladder and it FAILED — call codeloop_kill_modal_window with hwnd ${detection.hwnd ?? "(from codeloop_handle_modal)"} now. `
+                            : `Stop sending raw clicks / Escape keystrokes against it and call codeloop_handle_modal with decision: "cancel" or "dismiss" — the multi-strategy ladder (Escape → Alt+F4 → UIA Invoke "Close" → EndDialog) handles file dialogs the keystroke path cannot. If codeloop_handle_modal returns escalation: "kill_window_required", call codeloop_kill_modal_window with the returned hwnd. `;
+                        modalPersistenceDirective =
+                            `\n\n[CodeLoop F4] HARD: A ${detection.modal_kind ?? "modal"} dialog (${desc}) is STILL present after this interaction ` +
+                                `(${consecutive} consecutive interactions have not cleared it). ` +
+                                killHint +
+                                `Continuing to ignore this modal will fail the cycle_issues_acknowledged gate and block ready_for_review.`;
+                    }
                 }
                 else {
                     // Modal cleared — reset the tracker for this app so the next