Merge branch '7.2' of https://github.com/lucee/Lucee into 7.2

Author: michaeloffner

core/src/main/java/lucee/runtime/PageContextImpl.java

@@ -2834,6 +2834,11 @@ private final void execute(PageSource ps, boolean throwExcpetion, boolean onlyTo
 				if (fdEnabled) {
 					FDSignal.signal(pe, false);
 				}
+				// External debugger extension - uncaught exception
+				if (debuggerFrames != null) {
+					DebuggerListener debugListener = DebuggerRegistry.getListener();
+					debuggerNotifyException(debugListener, pe, false);
+				}
 				listener.onError(this, pe); // call Application.onError()
 			}
 			else log(false);
@@ -3435,27 +3440,10 @@ public void _setCatch(PageException pe, String name, boolean caught, boolean sto
 			if (fdEnabled) {
 				FDSignal.signal(pe, caught);
 			}
-			// External debugger (luceedebug) - frames are still intact at this point
+			// External debugger extension - frames are still intact at this point
 			if (debuggerFrames != null) {
 				DebuggerListener listener = DebuggerRegistry.getListener();
-				if (listener != null && listener.isClientConnected() && listener.onException(this, pe, caught)) {
-					// Get file/line from exception for debugger display
-					String file = null;
-					int line = 0;
-					if (pe instanceof PageExceptionImpl) {
-						PageExceptionImpl pei = (PageExceptionImpl) pe;
-						file = pei.getFile(getConfig());
-						try {
-							String lineStr = pei.getLine(getConfig());
-							if (lineStr != null && !lineStr.isEmpty()) {
-								line = Integer.parseInt(lineStr);
-							}
-						}
-						catch (NumberFormatException ignored) {}
-					}
-					String label = caught ? "Caught exception: " : "Uncaught exception: ";
-					debuggerSuspend(file, line, label + pe.getClass().getSimpleName());
-				}
+				debuggerNotifyException(listener, pe, caught);
 			}
 		}
 		// boolean outer = exception != null && exception == pe;
@@ -3592,22 +3580,13 @@ public void popDebuggerFrame() {
 
 	/**
 	 * Get all debugger frames for the current call stack. Returns null if debugger is not enabled.
+	 * Called via reflection by the debugger extension.
 	 */
 	public DebuggerFrame[] getDebuggerFrames() {
 		if (debuggerFrames == null) return null;
 		return debuggerFrames.toArray(new DebuggerFrame[0]);
 	}
 
-	/**
-	 * Update the line number of the topmost debugger frame. Called on each CFML line when
-	 * stepping/breakpoints are active.
-	 */
-	public void setDebuggerLine(int line) {
-		if (debuggerFrames != null && !debuggerFrames.isEmpty()) {
-			debuggerFrames.getLast().setLine(line);
-		}
-	}
-
 	/**
 	 * Get the topmost debugger frame, or null if none.
 	 */
@@ -3616,6 +3595,29 @@ public DebuggerFrame getTopmostDebuggerFrame() {
 		return debuggerFrames.getLast();
 	}
 
+	/**
+	 * Notify the debugger listener of an exception and suspend if requested.
+	 */
+	private void debuggerNotifyException(DebuggerListener listener, PageException pe, boolean caught) {
+		if (listener == null || !listener.isClientConnected() || !listener.onException(this, pe, caught)) return;
+		String file = null;
+		int line = 0;
+		if (pe instanceof PageExceptionImpl) {
+			PageExceptionImpl pei = (PageExceptionImpl) pe;
+			file = pei.getFile(getConfig());
+			try {
+				String lineStr = pei.getLine(getConfig());
+				if (lineStr != null && !lineStr.isEmpty()) {
+					line = Integer.parseInt(lineStr);
+				}
+			}
+			catch (NumberFormatException ignored) {
+			}
+		}
+		String label = caught ? "Caught exception: " : "Uncaught exception: ";
+		debuggerSuspend(file, line, label + pe.getClass().getSimpleName());
+	}
+
 	// Debugger suspension support
 	private volatile boolean debuggerSuspended = false;
 	private volatile String debuggerSuspendLabel = null;
@@ -3687,13 +3689,18 @@ private void debuggerSuspendImpl(String file, int line, String label) {
 		synchronized (debuggerSuspendLock) {
 			while (debuggerSuspended) {
 				try {
-					debuggerSuspendLock.wait();
+					debuggerSuspendLock.wait(5000);
 				}
 				catch (InterruptedException e) {
 					Thread.currentThread().interrupt();
 					LogUtil.log(this, "application", "debugger", e, Log.LEVEL_WARN);
 					break;
 				}
+				// Auto-resume if debugger disconnected while suspended
+				if (debuggerSuspended && !DebuggerRegistry.isClientConnected()) {
+					LogUtil.log(Log.LEVEL_WARN, "application", "Debugger disconnected while thread suspended - auto-resuming");
+					debuggerSuspended = false;
+				}
 			}
 		}
 		debuggerTotalSuspendedNanos += System.nanoTime() - debuggerSuspendStartNano;
@@ -3707,6 +3714,7 @@ private void debuggerSuspendImpl(String file, int line, String label) {
 
 	/**
 	 * Resume execution after debugger suspension.
+	 * Called via reflection by the debugger extension.
 	 */
 	public void debuggerResume() {
 		debuggerSuspended = false;
@@ -3717,25 +3725,20 @@ public void debuggerResume() {
 
 	/**
 	 * Check if this PageContext is currently suspended.
+	 * Available for debugger extensions via reflection.
 	 */
 	public boolean isDebuggerSuspended() {
 		return debuggerSuspended;
 	}
 
 	/**
 	 * Get the label of the current suspension point, or null.
+	 * Available for debugger extensions via reflection.
 	 */
 	public String getDebuggerSuspendLabel() {
 		return debuggerSuspendLabel;
 	}
 
-	/**
-	 * Get total time spent suspended (for adjusting request timeouts).
-	 */
-	public long getDebuggerTotalSuspendedNanos() {
-		return debuggerTotalSuspendedNanos;
-	}
-
 	/**
 	 * Get total time spent suspended in milliseconds, including current suspend if active. Used for
 	 * adjusting request timeout calculations.

core/src/main/java/lucee/runtime/debug/DebuggerListener.java

@@ -3,7 +3,7 @@
 import lucee.runtime.PageContext;
 
 /**
- * Listener interface for external debuggers (e.g., luceedebug/VS Code DAP).
+ * Listener interface for external debugger extensions (e.g., VS Code DAP).
  * Allows debuggers to be notified of suspend/resume events and to register breakpoints.
  *
  * Only one debugger listener is supported at a time.
@@ -13,7 +13,7 @@ public interface DebuggerListener {
 	/**
 	 * Get the name of this debugger for logging purposes.
 	 *
-	 * @return A human-readable name (e.g., "luceedebug")
+	 * @return A human-readable name (e.g., "debugger")
 	 */
 	String getName();
 

core/src/main/java/lucee/runtime/debug/DebuggerPrintStream.java

@@ -1,57 +1,56 @@
 package lucee.runtime.debug;
 
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.io.PrintStream;
 
 /**
  * PrintStream wrapper that tees output to the DebuggerListener.
- * Installed on System.out/err when DEBUGGER_SECRET is set.
+ * Installed on System.out/err when DEBUGGER_DAP_SECRET is set.
  * Always passes through to the original stream; only notifies listener when active.
+ *
+ * Uses an OutputStream wrapper because PrintStream.print/println use a private
+ * internal write path (BufferedWriter → OutputStreamWriter → OutputStream) that
+ * bypasses the public write(byte[]) methods. Wrapping the OutputStream ensures
+ * ALL output paths are intercepted.
  */
 public class DebuggerPrintStream extends PrintStream {
-	private final PrintStream original;
-	private final boolean isStdErr;
 
 	public DebuggerPrintStream(PrintStream original, boolean isStdErr) {
-		super(original, true); // autoFlush=true
-		this.original = original;
-		this.isStdErr = isStdErr;
+		super(new NotifyingOutputStream(original, isStdErr), true);
 	}
 
-	@Override
-	public void write(byte[] buf, int off, int len) {
-		super.write(buf, off, len);
-		notifyListener(new String(buf, off, len));
-	}
-
-	@Override
-	public void write(byte[] buf) {
-		super.write(buf, 0, buf.length);
-		notifyListener(new String(buf));
-	}
+	/**
+	 * OutputStream that forwards all writes to the original stream
+	 * and notifies the DebuggerListener of new output.
+	 */
+	private static class NotifyingOutputStream extends FilterOutputStream {
+		private final boolean isStdErr;
 
-	@Override
-	public void write(int b) {
-		super.write(b);
-		// Single byte - notify immediately (some libs write char-by-char)
-		notifyListener(String.valueOf((char) b));
-	}
+		NotifyingOutputStream(OutputStream original, boolean isStdErr) {
+			super(original);
+			this.isStdErr = isStdErr;
+		}
 
-	// Note: We only override write() methods to notify the listener.
-	// Do NOT override print/println - they internally call write() and
-	// would cause double notifications.
+		@Override
+		public void write(byte[] buf, int off, int len) throws IOException {
+			out.write(buf, off, len);
+			notifyListener(new String(buf, off, len));
+		}
 
-	private void notifyListener(String text) {
-		if (text == null || text.isEmpty()) return;
-		DebuggerListener listener = DebuggerRegistry.getListener();
-		if (listener != null && listener.isClientConnected()) {
-			listener.onOutput(text, isStdErr);
+		@Override
+		public void write(int b) throws IOException {
+			out.write(b);
+			notifyListener(String.valueOf((char) b));
 		}
-	}
 
-	/**
-	 * Get the original stream (for unwrapping if needed).
-	 */
-	public PrintStream getOriginal() {
-		return original;
+		private void notifyListener(String text) {
+			if (text == null || text.isEmpty()) return;
+			DebuggerListener listener = DebuggerRegistry.getListener();
+			if (listener != null && listener.isClientConnected()) {
+				listener.onOutput(text, isStdErr);
+			}
+		}
 	}
 }

core/src/main/java/lucee/runtime/debug/DebuggerRegistry.java

@@ -8,7 +8,7 @@
 /**
  * Static registry for the debugger listener. Only one debugger listener is supported at a time.
  *
- * External debuggers (e.g., luceedebug) can access this via reflection:
+ * External debugger extensions can access this via reflection:
  *
  * Class<?> registryClass = Class.forName("lucee.runtime.debug.DebuggerRegistry"); Method
  * setListener = registryClass.getMethod("setListener",
@@ -32,18 +32,23 @@ private DebuggerRegistry() {
 	 * @return true if registration succeeded, false if secret is invalid
 	 */
 	public static boolean setListener(DebuggerListener l, String secret) {
-		// Unregister always allowed
+		String expectedSecret = ((ConfigPro) ThreadLocalPageContext.getConfig()).getDapSecret();
+		if (expectedSecret == null) {
+			LogUtil.log(Log.LEVEL_WARN, "application", "Debugger registration rejected - LUCEE_DAP_SECRET not configured");
+			return false;
+		}
+		if (!expectedSecret.equals(secret)) {
+			LogUtil.log(Log.LEVEL_WARN, "application", "Debugger registration rejected - invalid secret");
+			return false;
+		}
 		if (l == null) {
 			listener = null;
-			return true;
+			LogUtil.log(Log.LEVEL_INFO, "application", "External debugger unregistered");
 		}
-		// Registration requires valid secret
-		String expectedSecret = ((ConfigPro) ThreadLocalPageContext.getConfig()).getDapSecret();
-		if (expectedSecret == null || !expectedSecret.equals(secret)) {
-			return false;
+		else {
+			listener = l;
+			LogUtil.log(Log.LEVEL_INFO, "application", "External debugger registered [" + l.getName() + "]");
 		}
-		listener = l;
-		LogUtil.log(Log.LEVEL_INFO, "application", "External debugger registered [" + l.getName() + "]");
 		return true;
 	}
 
@@ -56,15 +61,6 @@ public static DebuggerListener getListener() {
 		return listener;
 	}
 
-	/**
-	 * Check if a debugger listener is registered.
-	 *
-	 * @return true if a listener is registered
-	 */
-	public static boolean hasListener() {
-		return listener != null;
-	}
-
 	/**
 	 * Check if a debugger client is connected and ready to handle breakpoints. Returns false if no
 	 * listener is registered, or if the listener is registered but no debugger client is attached.

core/src/main/java/lucee/runtime/engine/CFMLEngineImpl.java

@@ -230,10 +230,9 @@ public final class CFMLEngineImpl implements CFMLEngine {
 	public static final PrintStream CONSOLE_OUT;
 
 	static {
-		// Install debugger print streams if debugger is enabled
-		boolean debuggerEnabled = Caster.toBooleanValue(SystemUtil.getSystemPropOrEnvVar("lucee.debugger.enabled", null), false);
-
-		if (debuggerEnabled) {
+		// Install debugger print streams when DAP secret is set (debugger extension expected)
+		String dapSecret = SystemUtil.getSystemPropOrEnvVar("lucee.dap.secret", null);
+		if (dapSecret != null && !dapSecret.trim().isEmpty()) {
 			CONSOLE_OUT = new DebuggerPrintStream(System.out, false);
 			CONSOLE_ERR = new DebuggerPrintStream(System.err, true);
 			System.setOut(CONSOLE_OUT);