neural-loom 0.3.0 → 0.3.1

package/src/app/components/TerminalConsole.tsx

@@ -19,22 +19,33 @@ 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;
+}
+
+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" };
+
+  let apiError = "";
 
   // Preferred path: async Clipboard API. Reliable in a secure context, which
   // includes localhost (NeuralLoom's default bind).
   if (window.isSecureContext && navigator.clipboard?.writeText) {
     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) {
+      // Fall through to the execCommand fallback (e.g. not focused / denied).
+      apiError = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
     }
+  } else if (!window.isSecureContext) {
+    apiError = "not a secure context (access via http://localhost for the Clipboard API)";
   }
 
-  // Fallback: hidden textarea + execCommand("copy") for non-secure contexts
-  // (e.g. accessed over a plain-HTTP LAN address).
+  // Fallback: hidden textarea + execCommand("copy").
   try {
     const textArea = document.createElement("textarea");
     textArea.value = text;
@@ -47,10 +58,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, error: `execCommand returned false${apiError ? ` (clipboard API: ${apiError})` : ""}` };
   } catch (err) {
-    console.warn("Clipboard copy failed:", err);
-    return false;
+    const ex = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `${ex}${apiError ? ` | clipboard API: ${apiError}` : ""}` };
   }
 }
 
@@ -72,21 +84,34 @@ 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);
 
   // Copy the given text (or the current terminal selection) to the clipboard.
   // 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);
+    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");
+      }
     });
   }, []);
 
@@ -578,8 +603,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);