mixdog 0.9.0 → 0.9.2

package/src/runtime/agent/orchestrator/tools/patch.mjs

@@ -27,7 +27,7 @@
 //     responds with OK_PARTIAL plus a hex-encoded failures payload that
 //     the JS side surfaces per-entry.
 
-import { existsSync, readFileSync, realpathSync, statSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
@@ -581,6 +581,41 @@ function isPatchErrorText(text) {
   return /^Error:/i.test(String(text ?? '').trimStart());
 }
 
+// ── UI-only unified-diff side-channel ───────────────────────────────────────
+// apply_patch's MODEL-VISIBLE result stays the compact summary ("Applied 1
+// File (Native)\n  OK Modify path — +1 Line · -1 Line"). The standard unified
+// diff it builds internally (nativePatchStr) is stashed here, keyed by the
+// tool_use id, so the agent loop can attach it to the TUI tool-result message
+// as a UI-only field (never sent to the model). The TUI's expanded (ctrl+o)
+// raw view then colorizes it via the existing formatExpandedResult/diff path.
+// Size-capped per entry and FIFO-bounded so a huge patch (or a leaked entry
+// whose take() never ran) cannot grow the transcript item or this Map.
+const APPLY_PATCH_UI_DIFF_MAX_CHARS = 64 * 1024;
+const APPLY_PATCH_UI_DIFF_REGISTRY_MAX = 64;
+const _applyPatchUiDiffByCallId = new Map();
+
+function registerApplyPatchUiDiff(callId, diff) {
+  if (!callId || typeof diff !== 'string' || !diff.trim()) return;
+  let text = diff;
+  if (text.length > APPLY_PATCH_UI_DIFF_MAX_CHARS) {
+    text = `${text.slice(0, APPLY_PATCH_UI_DIFF_MAX_CHARS)}\n… [diff truncated for display]`;
+  }
+  if (_applyPatchUiDiffByCallId.size >= APPLY_PATCH_UI_DIFF_REGISTRY_MAX) {
+    const oldest = _applyPatchUiDiffByCallId.keys().next().value;
+    if (oldest !== undefined) _applyPatchUiDiffByCallId.delete(oldest);
+  }
+  _applyPatchUiDiffByCallId.set(callId, text);
+}
+
+// Consume (read + remove) the UI-only unified diff for a tool_use id. Returns
+// null when none was registered (error/rename-only/partial-fail/dry-skip).
+export function takeApplyPatchUiDiff(callId) {
+  if (!callId) return null;
+  const value = _applyPatchUiDiffByCallId.get(callId) || null;
+  if (value != null) _applyPatchUiDiffByCallId.delete(callId);
+  return value;
+}
+
 // Count how many source lines a hunk consumes vs produces so we can
 // surface a concise `lines_changed` figure without re-diffing.
 function countHunkChanges(hunks) {
@@ -2806,6 +2841,14 @@ async function apply_patch(args, cwd, options = {}) {
     if (renameLines.length > 0 && !isPatchErrorText(nativeResult)) {
       combined = `${renameLines.join('\n')}\n${nativeResult}`;
     }
+    // UI-only: stash the standard unified diff (nativePatchStr) keyed by the
+    // tool_use id so the agent loop can attach it to the TUI tool-result for the
+    // expanded (ctrl+o) colored-diff view. NEVER added to the model-visible
+    // result string. Only on clean success — partial/failed cases surface as an
+    // Error card with the failure text instead.
+    if (!isPatchErrorText(combined) && options?.toolCallId) {
+      registerApplyPatchUiDiff(options.toolCallId, nativePatchStr);
+    }
     if (!isPatchErrorText(combined) && rejectedV4AHunks.length > 0) {
       const tail = [
         '',
@@ -2824,6 +2867,74 @@ async function apply_patch(args, cwd, options = {}) {
 export const __patchTestHooks = { findFirstFailingUnifiedHunk, computeUnifiedChangeBand, collectUnifiedOps, unifiedOldLinesMatchAt, splitBufferLinesForPatch };
 
 export async function executePatchTool(name, args, cwd, options = {}) {
+  // --- Opt-in failure replay capture -------------------------------------
+  // When MIXDOG_PATCH_REPLAY_CAPTURE=1, a FAILED apply_patch (throw or
+  // "Error:" body) is frozen to a replay file with the ORIGINAL patch args,
+  // cwd, error, and a full snapshot of every target file's current bytes, so
+  // scripts/patch-replay.mjs can re-run the exact failing call against updated
+  // code. Local dev only; the patch body is stored verbatim (no redaction).
+  return _executePatchTool(name, args, cwd, options);
+}
+
+function patchReplayDir() {
+  const base = process.env.MIXDOG_PATCH_REPLAY_DIR
+    || pathJoin(getPluginDataDir(), 'history', 'patch-replays');
+  return base;
+}
+
+function getPluginDataDir() {
+  try { return getPluginData(); } catch { /* fall through */ }
+  return process.env.MIXDOG_DATA_DIR || pathJoin(process.env.USERPROFILE || process.env.HOME || '.', '.mixdog', 'data');
+}
+
+function patchTargetPaths(patchStr, basePath) {
+  const out = [];
+  const re = /^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/gm;
+  let m;
+  while ((m = re.exec(String(patchStr || '')))) {
+    const rel = m[1].trim();
+    if (rel) out.push(rel);
+  }
+  // unified headers
+  const ure = /^\+\+\+ (?:b\/)?(.+)$/gm;
+  while ((m = ure.exec(String(patchStr || '')))) {
+    const rel = m[1].trim();
+    if (rel && rel !== '/dev/null') out.push(rel);
+  }
+  return [...new Set(out)];
+}
+
+function maybeCapturePatchReplay(args, cwd, errorText) {
+  if (process.env.MIXDOG_PATCH_REPLAY_CAPTURE !== '1') return;
+  try {
+    const patchStr = typeof args?.patch === 'string' ? args.patch : '';
+    const basePath = pathResolve(String(args?.base_path || cwd || process.cwd()));
+    const dir = patchReplayDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const rels = patchTargetPaths(patchStr, basePath);
+    const files = {};
+    for (const rel of rels) {
+      try {
+        const abs = isAbsolute(rel) ? rel : pathResolve(basePath, rel);
+        files[rel] = existsSync(abs) ? readFileSync(abs, 'utf8') : null;
+      } catch { files[rel] = null; }
+    }
+    const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const record = {
+      id,
+      ts: Date.now(),
+      tool: 'apply_patch',
+      args: { patch: patchStr, base_path: args?.base_path ?? null, format: args?.format ?? null, dry_run: args?.dry_run ?? null, fuzzy: args?.fuzzy ?? null, reject_partial: args?.reject_partial ?? null },
+      cwd: basePath,
+      error_first_line: String(errorText || '').split('\n')[0].slice(0, 400),
+      targets: rels,
+      file_snapshots: files,
+    };
+    writeFileSync(pathJoin(dir, `${id}.json`), JSON.stringify(record, null, 2), { mode: 0o600 });
+  } catch { /* capture is best-effort; never affect the tool result */ }
+}
+
+async function _executePatchTool(name, args, cwd, options = {}) {
   const effectiveCwd = cwd || process.cwd();
   switch (name) {
     case 'apply_patch': {
@@ -2831,8 +2942,11 @@ export async function executePatchTool(name, args, cwd, options = {}) {
       try {
         result = await apply_patch(args || {}, effectiveCwd, options);
       } catch (err) {
-        return `Error: ${err?.message || String(err)}`;
+        const errText = `Error: ${err?.message || String(err)}`;
+        maybeCapturePatchReplay(args, effectiveCwd, errText);
+        return errText;
       }
+      if (isPatchErrorText(String(result))) maybeCapturePatchReplay(args, effectiveCwd, String(result));
       // ② completion progress (claude "Found N" parity). Best-effort, no-op
       // when onProgress is absent (no progressToken). Never throws — only
       // emits on success (an "Error:" body is left to the tool result alone).

package/src/runtime/channels/backends/discord.mjs

@@ -16,10 +16,11 @@ import {
   realpathSync
 } from "fs";
 import { join, sep } from "path";
-import { chunk } from "../lib/format.mjs";
+import { createHash } from "crypto";
+import { chunk, formatForDiscord, MAX_DISCORD_MESSAGE } from "../lib/format.mjs";
 import { withConfigLock } from "../lib/config-lock.mjs";
 import { readSection, updateSection } from "../../shared/config.mjs";
-const MAX_CHUNK_LIMIT = 2e3;
+const MAX_CHUNK_LIMIT = MAX_DISCORD_MESSAGE;
 const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 const RECENT_SENT_CAP = 200;
 function defaultAccess() {
@@ -52,6 +53,7 @@ function safeAttName(att) {
 }
 class DiscordBackend {
   name = "discord";
+  MAX_MESSAGE_LENGTH = MAX_DISCORD_MESSAGE;
   onMessage = null;
   onInteraction = null;
   onModalRequest = null;
@@ -77,6 +79,9 @@ class DiscordBackend {
     this.initialAccess = normalizeAccess(config.access);
     this.client = null;
   }
+  formatOutgoing(text) {
+    return formatForDiscord(text);
+  }
   // ── Lifecycle ──────────────────────────────────────────────────────
   async connect() {
     // Re-entry guard: if a connect() is already in-flight or completed, return
@@ -335,33 +340,118 @@ class DiscordBackend {
       }
     }
     if (files.length > 10) throw new Error("max 10 attachments per message");
-    if (text && this.sendCount > 0) {
+    // Resume-token support (opaque to callers). A partial-send failure hands the
+    // caller a token { hash, nextChunkIdx, sentIds, prefixed }; a requeued retry
+    // passes it back so we resume at the failed chunk instead of re-sending
+    // chunks that already landed.
+    //
+    // The "\u3164\n" prefix is applied from this.sendCount, which advances when
+    // ANY backend send fully succeeds. Between the original partial failure and
+    // this retry, an unrelated send (scheduler/lifecycle/permission) can flip
+    // sendCount from 0 to >0, which would change the prefix — and therefore the
+    // chunked text and its hash — breaking the token match and forcing a
+    // duplicate full-resend. To keep the retry byte-identical to the original
+    // attempt, freeze the prefix decision in the token and reuse it here instead
+    // of recomputing from the (possibly changed) current sendCount.
+    const resumeToken = opts?.resumeToken;
+    const applyPrefix = (resumeToken && typeof resumeToken.prefixed === "boolean")
+      ? resumeToken.prefixed
+      : (text && this.sendCount > 0 ? true : false);
+    if (text && applyPrefix) {
       text = "\u3164\n" + text;
     }
     const access = this.loadAccess();
     const limit = Math.max(1, Math.min(access.textChunkLimit ?? MAX_CHUNK_LIMIT, MAX_CHUNK_LIMIT));
     const replyMode = access.replyToMode ?? "off";
     const chunks = chunk(text, limit);
+    // Hash the FINAL prefixed text so the token pins to the exact bytes sent.
+    const contentHash = createHash("md5").update(text).digest("hex");
+    let startIdx = 0;
     const sentIds = [];
+    // Resume only when BOTH the text hash AND the effective chunk limit match.
+    // The token's nextChunkIdx is an index into the chunk array, which is only
+    // meaningful for the same `limit`; if access.textChunkLimit changed during
+    // the retry window the same text can split differently, so a stale index
+    // could skip or duplicate a range. On mismatch fall through to startIdx=0
+    // (full, safe resend).
+    if (resumeToken && resumeToken.hash === contentHash && resumeToken.limit === limit) {
+      startIdx = Math.max(0, Math.min(resumeToken.nextChunkIdx ?? 0, chunks.length));
+      // Seed sentIds with the already-delivered ids so the returned list stays
+      // complete across the resume boundary.
+      if (Array.isArray(resumeToken.sentIds)) sentIds.push(...resumeToken.sentIds);
+    }
     try {
-      for (let i = 0; i < chunks.length; i++) {
+      for (let i = startIdx; i < chunks.length; i++) {
         const shouldReplyTo = replyTo != null && replyMode !== "off" && (replyMode === "all" || i === 0);
         const embeds = i === 0 ? opts?.embeds ?? [] : [];
         const components = i === 0 ? opts?.components ?? [] : [];
-        const sent = await ch.send({
+        const payload = {
           content: chunks[i],
           ...embeds.length > 0 ? { embeds } : {},
           ...components.length > 0 ? { components } : {},
           ...i === 0 && files.length > 0 ? { files } : {},
           ...shouldReplyTo ? { reply: { messageReference: replyTo, failIfNotExists: false } } : {}
-        });
-        this.noteSent(sent.id);
-        sentIds.push(sent.id);
+        };
+        // Per-chunk send with retry. On 429 honour Retry-After; on other
+        // transient errors do a short backoff. Cap at 3 attempts per chunk;
+        // after the cap throw an error carrying a resume token so the caller
+        // (output-forwarder) requeues the WHOLE item and the next sendMessage
+        // resumes at this chunk index instead of re-sending 0..i-1.
+        let attempt = 0;
+        for (;;) {
+          try {
+            const sent = await ch.send(payload);
+            this.noteSent(sent.id);
+            sentIds.push(sent.id);
+            break;
+          } catch (err) {
+            attempt++;
+            const status = err?.status ?? err?.code ?? err?.httpStatus;
+            // Classify: PERMANENT = a 4xx client error (unknown channel/message,
+            // missing access/permissions, 404 …) that will never succeed on
+            // retry. TRANSIENT = 429, any 5xx, or network error (no status). A
+            // permanent error must NOT retry-loop and must NOT carry a resume
+            // token — throw it immediately flagged so the forwarder drops the
+            // item instead of requeuing forever.
+            const isPermanent = typeof status === "number" && status >= 400 && status < 500 && status !== 429;
+            if (isPermanent) {
+              const e = err instanceof Error ? err : new Error(String(err));
+              e.permanent = true;
+              throw e;
+            }
+            if (attempt >= 3) {
+              // Attach an opaque resume token pointing at the chunk that failed
+              // (i). sentIds holds every chunk already delivered (including any
+              // seeded from a prior token).
+              const e = err instanceof Error ? err : new Error(String(err));
+              e.resumeToken = { hash: contentHash, nextChunkIdx: i, sentIds: [...sentIds], prefixed: applyPrefix, limit };
+              throw e;
+            }
+            if (status === 429) {
+              // @discordjs/rest RateLimitError.retryAfter is ALWAYS in ms
+              // (no unit guess). Clamp to [0, 60000]; fall back to 1s when the
+              // field is absent/invalid. (discord.js also auto-sleeps rate
+              // limits internally, so we rarely even reach this branch.)
+              const retryAfterMs = Number(err?.retryAfter);
+              const ms = Number.isFinite(retryAfterMs) && retryAfterMs > 0 ? Math.min(retryAfterMs, 60_000) : 1000;
+              await new Promise((r) => setTimeout(r, ms));
+            } else {
+              // Other transient error (5xx / network): short backoff.
+              await new Promise((r) => setTimeout(r, 1000));
+            }
+          }
+        }
       }
       this.sendCount += sentIds.length;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`send failed after ${sentIds.length}/${chunks.length} chunk(s): ${msg}`);
+      const wrapped = new Error(`send failed after ${sentIds.length}/${chunks.length} chunk(s): ${msg}`);
+      // Preserve the opaque resume token across the rewrap so the caller can
+      // persist it on the queue item and resume on retry.
+      if (err?.resumeToken) wrapped.resumeToken = err.resumeToken;
+      // Propagate the permanent flag so the forwarder drops (not requeues) it.
+      if (err?.permanent) wrapped.permanent = true;
+      throw wrapped;
     }
     return { sentIds };
   }