neural-loom 0.3.0 → 0.3.2

package/src/app/components/TerminalConsole.tsx

@@ -19,22 +19,39 @@ interface LogBufferItem {
   message?: string;
 }
 
-async function copyTextToClipboard(text: string): Promise<boolean> {
-  if (typeof window === "undefined" || !text) return false;
+interface CopyResult {
+  ok: boolean;
+  method?: "clipboard-api" | "execCommand";
+  error?: string;
+}
 
-  // Preferred path: async Clipboard API. Reliable in a secure context, which
-  // includes localhost (NeuralLoom's default bind).
-  if (window.isSecureContext && navigator.clipboard?.writeText) {
+async function copyTextToClipboard(text: string): Promise<CopyResult> {
+  if (typeof window === "undefined") return { ok: false, error: "no window" };
+  if (!text) return { ok: false, error: "empty selection" };
+
+  // Secure context (localhost, PWA, https): trust ONLY the async Clipboard API.
+  // It is reliable when it resolves — and we deliberately don't fall back to
+  // execCommand here, because execCommand can return a false-positive `true`
+  // (reporting success while copying nothing). Surfacing the real rejection is
+  // more useful than a fake "Copied".
+  if (window.isSecureContext) {
+    if (!navigator.clipboard?.writeText) {
+      return { ok: false, error: "Clipboard API unavailable in this browser" };
+    }
     try {
       await navigator.clipboard.writeText(text);
-      return true;
-    } catch {
-      // Fall through to the execCommand fallback (e.g. permission denied).
+      return { ok: true, method: "clipboard-api" };
+    } catch (err) {
+      return {
+        ok: false,
+        method: "clipboard-api",
+        error: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+      };
     }
   }
 
-  // Fallback: hidden textarea + execCommand("copy") for non-secure contexts
-  // (e.g. accessed over a plain-HTTP LAN address).
+  // Non-secure context (e.g. plain-HTTP LAN access): execCommand is the only
+  // option. Note its success value is not fully reliable.
   try {
     const textArea = document.createElement("textarea");
     textArea.value = text;
@@ -47,10 +64,11 @@ async function copyTextToClipboard(text: string): Promise<boolean> {
     textArea.select();
     const successful = document.execCommand("copy");
     document.body.removeChild(textArea);
-    return successful;
+    if (successful) return { ok: true, method: "execCommand" };
+    return { ok: false, method: "execCommand", error: "execCommand returned false (use http://localhost for the Clipboard API)" };
   } catch (err) {
-    console.warn("Clipboard copy failed:", err);
-    return false;
+    const ex = err instanceof Error ? err.message : String(err);
+    return { ok: false, method: "execCommand", error: ex };
   }
 }
 
@@ -72,21 +90,40 @@ export default function TerminalConsole({ sessionId, height = "400px", wsPort =
   const [caseSensitive, setCaseSensitive] = useState(false);
   const searchAddonRef = useRef<SearchAddon | null>(null);
 
-  // Copy feedback ("Copied!" indicator)
+  // Copy feedback ("Copied!" indicator) and last error (surfaced for diagnosis)
   const [copied, setCopied] = useState(false);
+  const [copyError, setCopyError] = useState<string | null>(null);
   const copiedTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Last non-empty terminal selection. The toolbar/right-click read this because
+  // clicking a button/menu clears the live xterm selection before the handler runs.
+  const lastSelectionRef = useRef("");
 
-  // Copy the given text (or the current terminal selection) to the clipboard.
+  // Copy the given text (or the last/current terminal selection) to the clipboard.
+  // IMPORTANT: must be invoked synchronously inside a user gesture (mouseup, click,
+  // keydown) so the Clipboard API write is permitted — otherwise it silently fails.
   // Stable identity so the terminal effect can use it without re-initializing.
-  const copySelection = useCallback((text?: string): void => {
+  // `explicit` = triggered by a button/shortcut (surface "nothing selected").
+  const copySelection = useCallback((text?: string, explicit = false): void => {
     const term = xtermRef.current;
-    const selection = (text ?? term?.getSelection() ?? "").trim();
-    if (!selection) return;
-    copyTextToClipboard(selection).then((ok) => {
-      if (!ok) return;
-      setCopied(true);
-      if (copiedTimerRef.current) clearTimeout(copiedTimerRef.current);
-      copiedTimerRef.current = setTimeout(() => setCopied(false), 1200);
+    const live = term?.getSelection() ?? "";
+    const selection = (text ?? (live || lastSelectionRef.current) ?? "").trim();
+    if (!selection) {
+      if (explicit) {
+        setCopyError("Nothing selected to copy");
+        setTimeout(() => setCopyError(null), 2500);
+      }
+      return;
+    }
+    copyTextToClipboard(selection).then((result) => {
+      if (result.ok) {
+        setCopyError(null);
+        setCopied(true);
+        if (copiedTimerRef.current) clearTimeout(copiedTimerRef.current);
+        copiedTimerRef.current = setTimeout(() => setCopied(false), 1200);
+      } else {
+        console.error("[TerminalConsole] copy failed:", result.error);
+        setCopyError(result.error || "copy failed");
+      }
     });
   }, []);
 
@@ -220,31 +257,39 @@ export default function TerminalConsole({ sessionId, height = "400px", wsPort =
     const handleMouseDown = (e: MouseEvent) => {
       if (e.button === 2 && term.hasSelection()) e.stopPropagation();
     };
+    // Copy-on-select. This runs on the bubble phase AFTER xterm has finalized the
+    // selection, and — crucially — synchronously inside the mouseup user gesture,
+    // so the Clipboard API write is allowed (the previous setTimeout ran outside
+    // the gesture and silently failed). Left-button only.
     const handleMouseUp = (e: MouseEvent) => {
-      if (e.button === 2 && term.hasSelection()) e.stopPropagation();
+      if (e.button === 2 && term.hasSelection()) {
+        e.stopPropagation();
+        return;
+      }
+      if (e.button === 0) {
+        const sel = term.getSelection();
+        if (sel && sel.trim()) copySelection(sel);
+      }
     };
     const handleContextMenu = (e: MouseEvent) => {
-      if (term.hasSelection()) {
+      const sel = term.getSelection() || lastSelectionRef.current;
+      if (sel && sel.trim()) {
         e.preventDefault();
-        copySelection(term.getSelection());
-        term.clearSelection();
+        copySelection(sel);
       }
     };
     if (container) {
       container.addEventListener("mousedown", handleMouseDown, true);
-      container.addEventListener("mouseup", handleMouseUp, true);
+      // bubble phase: xterm has already committed the selection by now
+      container.addEventListener("mouseup", handleMouseUp);
       container.addEventListener("contextmenu", handleContextMenu);
     }
 
-    // Copy-on-select: capture the selection the moment it is made. Claude Code's
-    // TUI redraws constantly, which clears the xterm selection — so we copy
-    // immediately (debounced) rather than waiting for a later Ctrl+C/right-click.
-    let selTimer: ReturnType<typeof setTimeout> | null = null;
+    // Track the latest non-empty selection so button / shortcut / right-click can
+    // copy it even after a click or redraw clears the live xterm selection.
     const selDisposable = term.onSelectionChange(() => {
       const sel = term.getSelection();
-      if (!sel || !sel.trim()) return;
-      if (selTimer) clearTimeout(selTimer);
-      selTimer = setTimeout(() => copySelection(sel), 150);
+      if (sel && sel.trim()) lastSelectionRef.current = sel;
     });
 
     // Attach search key handler and clipboard copy handler
@@ -451,13 +496,12 @@ export default function TerminalConsole({ sessionId, height = "400px", wsPort =
     return () => {
       isDisposed = true;
       clearTimeout(fitTimeout);
-      if (selTimer) clearTimeout(selTimer);
       selDisposable.dispose();
       resizeObserver.disconnect();
       ws.close();
       if (container) {
         container.removeEventListener("mousedown", handleMouseDown, true);
-        container.removeEventListener("mouseup", handleMouseUp, true);
+        container.removeEventListener("mouseup", handleMouseUp);
         container.removeEventListener("contextmenu", handleContextMenu);
       }
       try {
@@ -578,8 +622,24 @@ export default function TerminalConsole({ sessionId, height = "400px", wsPort =
               ✓ Copied
             </span>
           )}
+          {copyError && (
+            <span
+              title={copyError}
+              style={{
+                color: "#ff6b6b",
+                fontSize: "0.65rem",
+                fontWeight: 600,
+                maxWidth: "260px",
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap",
+              }}
+            >
+              ⚠ Copy failed: {copyError}
+            </span>
+          )}
           <button
-            onClick={() => copySelection()}
+            onClick={() => copySelection(undefined, true)}
             style={{
               padding: "2px 6px",
               borderRadius: "3px",

package/src/lib/agents/SessionPersister.ts

@@ -75,20 +75,36 @@ export class SessionPersister {
     try {
       const dir = this.getSessionsDir();
       const filePath = path.join(dir, `${id}.json`);
+      const json = JSON.stringify(data, null, 2);
       // Write to a temp file then rename, so a crash mid-write can't leave a
       // truncated/corrupt session file (rename is atomic on the same filesystem).
       const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-      fs.writeFile(tmpPath, JSON.stringify(data, null, 2), "utf8", (err) => {
+      fs.writeFile(tmpPath, json, "utf8", (err) => {
         if (err) {
-          console.error(`[SessionPersister] Failed to save session ${id} asynchronously:`, err);
+          console.error(`[SessionPersister] Failed to save session ${id}:`, err);
           return;
         }
-        fs.rename(tmpPath, filePath, (renameErr) => {
-          if (renameErr) {
-            console.error(`[SessionPersister] Failed to finalize session ${id}:`, renameErr);
-            fs.unlink(tmpPath, () => {});
-          }
-        });
+        // On Windows the rename can transiently fail with EPERM/EACCES/EBUSY when
+        // the destination is momentarily locked (AV scanners, the search indexer,
+        // or another open handle). Retry briefly, then fall back to overwriting
+        // the destination directly so the save still lands.
+        const tryRename = (attempts: number) => {
+          fs.rename(tmpPath, filePath, (renameErr) => {
+            if (!renameErr) return;
+            const code = (renameErr as NodeJS.ErrnoException).code;
+            if ((code === "EPERM" || code === "EACCES" || code === "EBUSY") && attempts > 0) {
+              setTimeout(() => tryRename(attempts - 1), 60);
+              return;
+            }
+            fs.writeFile(filePath, json, "utf8", (writeErr) => {
+              if (writeErr) {
+                console.error(`[SessionPersister] Failed to save session ${id}:`, writeErr);
+              }
+              fs.unlink(tmpPath, () => {});
+            });
+          });
+        };
+        tryRename(5);
       });
     } catch (err) {
       console.error(`[SessionPersister] Failed to save session ${id}:`, err);