fix(doctor): prevent clack note box from breaking copy-sensitive paths

ajwan8998 · claude · ajwan8998 · commit 07b5a7a57e86 · 2026-06-19T09:26:50.000+08:00
The wrapNoteMessage function correctly preserves copy-sensitive tokens (paths, URLs) as intact tokens, but the downstream clackNote renderer performs its own width-based wrapping inside the bordered box and is unaware of copy-sensitive token semantics. A path such as: ~/.openclaw/agents/main/sessions/uuid.jsonl.lock would land exactly at the box's right edge and get broken mid-extension. Add a second pass after the first-pass word wrap: any line that still exceeds the clack note box inner width is split at path-separator boundaries so each segment fits within the box without mid-word breaks. The fix benefits all doctor panels that use note() for paths: doctor-session-locks, doctor-state-integrity, doctor-volatile-fs, etc. Closes: #94730 Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/packages/terminal-core/src/note.ts b/packages/terminal-core/src/note.ts
@@ -9,6 +9,7 @@ const MIN_NOTE_COLUMNS = 80;
 const URL_PREFIX_RE = /^(https?:\/\/|file:\/\/)/i;
 const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
 const FILE_LIKE_RE = /^[a-zA-Z0-9._-]+$/;
+const NOTE_BOX_BORDER_WIDTH = 2;
 const suppressNotesStorage = new AsyncLocalStorage<boolean>();
 
 function isSuppressedByEnv(value: string | undefined): boolean {
@@ -22,6 +23,45 @@ function isSuppressedByEnv(value: string | undefined): boolean {
   return normalized !== "0" && normalized !== "false" && normalized !== "off";
 }
 
+function splitCopySensitiveToken(token: string, maxLen: number): string[] {
+  if (token.length <= maxLen) {
+    return [token];
+  }
+  // For paths and URLs, try to split at path separators.
+  const parts: string[] = [];
+  let remaining = token;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      parts.push(remaining);
+      break;
+    }
+    // Find the last path separator within maxLen boundary
+    const slice = remaining.slice(0, maxLen);
+    const lastSlash = Math.max(slice.lastIndexOf("/"), slice.lastIndexOf("\\"));
+    const breakPoint = lastSlash > 0 ? lastSlash + 1 : maxLen;
+    parts.push(remaining.slice(0, breakPoint));
+    remaining = remaining.slice(breakPoint);
+  }
+  return parts;
+}
+
+/**
+ * Splits a copy-sensitive token (path, URL) at path-separator boundaries
+ * so each segment fits within maxWidth. Used as a second pass after
+ * wrapLine has already performed word-wrapping — only reaches lines
+ * whose single copy-sensitive token still exceeds the clack note box
+ * inner width.
+ */
+function splitOversizedCopySensitiveLine(line: string, maxWidth: number): string[] {
+  const match = line.match(/^(\s*)(.*)$/);
+  const indent = match?.[1] ?? "";
+  const content = match?.[2] ?? "";
+  const segments = splitCopySensitiveToken(content, maxWidth);
+  // Each segment inherits the original indentation so the visual
+  // alignment stays consistent inside the clack note box.
+  return segments.map((seg) => indent + seg);
+}
+
 function splitLongWord(word: string, maxLen: number): string[] {
   if (maxLen <= 0) {
     return [word];
@@ -173,9 +213,19 @@ export function wrapNoteMessage(
   const text = coerceNoteMessage(message);
   const columns = options.columns ?? resolveNoteColumns(process.stdout.columns);
   const maxWidth = options.maxWidth ?? Math.max(40, Math.min(88, columns - 10));
+  const boxInnerWidth = columns - NOTE_BOX_BORDER_WIDTH;
   return text
     .split("\n")
     .flatMap((line) => wrapLine(line, maxWidth))
+    .flatMap((line) => {
+      if (visibleWidth(line) <= boxInnerWidth) {
+        return [line];
+      }
+      // After the first-pass word wrap, any remaining oversized line must
+      // contain a copy-sensitive token that overflowed maxWidth.  Split it
+      // at path-separator boundaries so it renders within clack's box.
+      return splitOversizedCopySensitiveLine(line, boxInnerWidth);
+    })
     .join("\n");
 }
 
