v0.0.3: clipboard watcher replaces the Ctrl+C keybinding approach

The keybinding override on Ctrl+C wasn't firing reliably in real
sessions — VS Code's terminal keybinding resolution is finicky and the
'terminalTextSelected' context key doesn't always match when users
copy via right-click or mouse-select.

New approach: watch the clipboard. An interval tick (default 300 ms,
paused when the VS Code window is unfocused) reads the current
clipboard text and, if the content has newlines and looks wrapped,
cleans it and writes the cleaned version back. Works no matter how
the user copied (Ctrl+C, right-click, mouse-select-copy, any shell
shortcut) because it operates at the clipboard layer, not the
keybinding layer.

Also:
- Status bar now updates on each clipboard tick: 'watching',
  'cleaned N clusters', 'no change (N lines)', etc.
- Settings: tidyPaste.watchClipboard (default true) and
  tidyPaste.watchIntervalMs (default 300).
- Manual command 'tidy-paste.terminalCopyClean' still works for users
  who want to trigger explicitly.
- Settings changes are picked up live without a reload.

Author: miller-joe

package.json

@@ -2,7 +2,7 @@
   "name": "tidy-paste",
   "displayName": "Tidy Paste",
   "description": "Cleans terminal-wrapped text on copy from VS Code's integrated terminal so pasted content arrives without stray line breaks or trailing whitespace.",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "publisher": "miller-joe",
   "license": "MIT",
   "repository": {
@@ -62,6 +62,16 @@
           "default": true,
           "description": "Master switch. When off, terminal copy behaves as default."
         },
+        "tidyPaste.watchClipboard": {
+          "type": "boolean",
+          "default": true,
+          "description": "Watch the clipboard for changes and clean wrapped content automatically. Works regardless of how you copied (Ctrl+C, right-click, mouse-select). Turn off if you only want the manual command."
+        },
+        "tidyPaste.watchIntervalMs": {
+          "type": "number",
+          "default": 300,
+          "description": "How often to check the clipboard for changes, in milliseconds. Lower = more responsive but uses slightly more CPU."
+        },
         "tidyPaste.appWrapColumn": {
           "type": "number",
           "default": 80,

src/extension.ts

@@ -3,6 +3,9 @@ import { cleanCopiedText } from "./cleaner.js";
 
 let output: vscode.OutputChannel | undefined;
 let statusBar: vscode.StatusBarItem | undefined;
+let watcherInterval: NodeJS.Timeout | undefined;
+let lastProcessed = "";
+let windowFocused = true;
 
 export function activate(context: vscode.ExtensionContext): void {
   output = vscode.window.createOutputChannel("Tidy Paste");
@@ -14,7 +17,7 @@ export function activate(context: vscode.ExtensionContext): void {
   );
   statusBar.text = "$(clippy) Tidy Paste: idle";
   statusBar.tooltip =
-    "Tidy Paste status. Updates on each terminal copy. Click to open the Output panel.";
+    "Tidy Paste status. Updates on each clipboard change. Click to open the Output panel.";
   statusBar.command = "tidy-paste.showOutput";
   statusBar.show();
   context.subscriptions.push(statusBar);
@@ -38,9 +41,28 @@ export function activate(context: vscode.ExtensionContext): void {
       output?.show(true);
     }),
   );
+
+  context.subscriptions.push(
+    vscode.window.onDidChangeWindowState((state) => {
+      windowFocused = state.focused;
+    }),
+  );
+
+  startClipboardWatcher(context);
+
+  // Re-read settings on change to pick up watcher toggling without reload.
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration((e) => {
+      if (e.affectsConfiguration("tidyPaste")) {
+        stopClipboardWatcher();
+        startClipboardWatcher(context);
+      }
+    }),
+  );
 }
 
 export function deactivate(): void {
+  stopClipboardWatcher();
   statusBar?.dispose();
   output?.dispose();
 }
@@ -51,62 +73,100 @@ function setStatus(text: string): void {
   }
 }
 
-async function terminalCopyClean(): Promise<void> {
+function startClipboardWatcher(context: vscode.ExtensionContext): void {
   const config = vscode.workspace.getConfiguration("tidyPaste");
-  if (config.get<boolean>("enabled") === false) {
-    await vscode.commands.executeCommand("workbench.action.terminal.copySelection");
+  if (!config.get<boolean>("watchClipboard", true)) {
+    setStatus("watcher off");
+    return;
+  }
+  if (!config.get<boolean>("enabled", true)) {
     setStatus("disabled");
     return;
   }
+  const intervalMs = Math.max(100, config.get<number>("watchIntervalMs") ?? 300);
 
-  await vscode.commands.executeCommand("workbench.action.terminal.copySelection");
+  watcherInterval = setInterval(() => {
+    if (!windowFocused) return; // cheap bail-out when VS Code is backgrounded
+    void tickClipboardWatcher();
+  }, intervalMs);
 
-  const raw = await vscode.env.clipboard.readText();
-  if (!raw) {
-    setStatus("empty clipboard");
-    return;
-  }
-  if (!raw.includes("\n")) {
-    setStatus("single line, no change");
-    return;
+  context.subscriptions.push({ dispose: stopClipboardWatcher });
+  setStatus("watching");
+}
+
+function stopClipboardWatcher(): void {
+  if (watcherInterval) {
+    clearInterval(watcherInterval);
+    watcherInterval = undefined;
   }
+}
 
-  const terminalColumns = getActiveTerminalColumns();
+async function tickClipboardWatcher(): Promise<void> {
+  try {
+    const current = await vscode.env.clipboard.readText();
+    if (!current || current === lastProcessed) return;
 
-  const result = cleanCopiedText(raw, {
-    terminalColumns,
-    appWrapColumn: config.get<number>("appWrapColumn") ?? 80,
-    minWrapLines: config.get<number>("minWrapLines") ?? 2,
-    stripTrailingWhitespace: config.get<boolean>("stripTrailingWhitespace") ?? true,
-    preserveCodeFences: config.get<boolean>("preserveCodeFences") ?? true,
-  });
+    // Quick bail-outs before the heavier cleanup.
+    if (!current.includes("\n")) {
+      lastProcessed = current;
+      return;
+    }
 
-  if (config.get<boolean>("debug")) {
-    output?.appendLine("------");
-    output?.appendLine(
-      `[copy] terminalColumns=${terminalColumns} appWrap=${config.get<number>("appWrapColumn") ?? 80} changed=${result.changed} rawLines=${raw.split("\n").length}`,
-    );
-    for (const n of result.notes) output?.appendLine(`  ${n}`);
-    if (!result.changed && raw.split("\n").length > 1) {
-      // Show the first few lines with their lengths so the user can see why the
-      // heuristic didn't fire.
-      const sample = raw.split("\n").slice(0, 6);
-      output?.appendLine("  [nothing matched] first lines:");
-      for (let i = 0; i < sample.length; i++) {
-        const line = sample[i]!;
-        const end = line.length > 0 ? JSON.stringify(line[line.length - 1]!) : "(empty)";
-        output?.appendLine(`    ${i}: len=${line.length} lastChar=${end}`);
+    const config = vscode.workspace.getConfiguration("tidyPaste");
+    if (!config.get<boolean>("enabled", true)) return;
+
+    const terminalColumns = getActiveTerminalColumns();
+    const result = cleanCopiedText(current, {
+      terminalColumns,
+      appWrapColumn: config.get<number>("appWrapColumn") ?? 80,
+      minWrapLines: config.get<number>("minWrapLines") ?? 2,
+      stripTrailingWhitespace: config.get<boolean>("stripTrailingWhitespace") ?? true,
+      preserveCodeFences: config.get<boolean>("preserveCodeFences") ?? true,
+    });
+
+    if (config.get<boolean>("debug", false)) {
+      output?.appendLine("------");
+      output?.appendLine(
+        `[watch] terminalColumns=${terminalColumns} changed=${result.changed} rawLines=${current.split("\n").length}`,
+      );
+      for (const n of result.notes) output?.appendLine(`  ${n}`);
+      if (!result.changed && current.split("\n").length > 1) {
+        const sample = current.split("\n").slice(0, 6);
+        output?.appendLine("  [nothing matched] first lines:");
+        for (let i = 0; i < sample.length; i++) {
+          const line = sample[i]!;
+          const end =
+            line.length > 0 ? JSON.stringify(line[line.length - 1]!) : "(empty)";
+          output?.appendLine(`    ${i}: len=${line.length} lastChar=${end}`);
+        }
       }
     }
+
+    if (result.changed) {
+      await vscode.env.clipboard.writeText(result.text);
+      lastProcessed = result.text; // don't re-process our own write
+      setStatus(`cleaned ${result.notes.length} cluster(s)`);
+    } else {
+      lastProcessed = current;
+      setStatus(`no change (${current.split("\n").length} lines)`);
+    }
+  } catch {
+    // Silent; clipboard access can fail mid-transition.
   }
+}
 
-  if (result.changed) {
-    await vscode.env.clipboard.writeText(result.text);
-    const joined = result.notes.length;
-    setStatus(joined > 0 ? `joined ${joined} cluster(s)` : "cleaned whitespace");
-  } else {
-    setStatus("no change");
+async function terminalCopyClean(): Promise<void> {
+  const config = vscode.workspace.getConfiguration("tidyPaste");
+  if (config.get<boolean>("enabled") === false) {
+    await vscode.commands.executeCommand("workbench.action.terminal.copySelection");
+    setStatus("disabled");
+    return;
   }
+
+  await vscode.commands.executeCommand("workbench.action.terminal.copySelection");
+  // The watcher will pick it up on its next tick. Kick a manual tick now
+  // so the user sees instant feedback if invoked from a keybinding.
+  await tickClipboardWatcher();
 }
 
 async function cleanEditorSelection(): Promise<void> {