fix(multiple): three journal-triage fixes (#2316, F17, #2319) (#2350)

* fix(cli): wheels stop lists running servers when cwd doesn't match a registered project

Closes #2316. Before this PR, running `wheels stop` from any directory
that isn't a registered project root (parent dir, sibling dir, deleted
project dir, anywhere else) silently printed "No running server found
for this directory." while the original Java/Catalina process kept
listening. The user's only escape hatch was `lsof -i :<port>` + `kill`.

This change adds a pre-delegation check in stop():

1. `$findServerForProject(projectRoot)` scans `~/.wheels/servers/*/.project-path`
   for an entry whose stored canonical path matches the current cwd.
2. If no match is found, `$listRunningWheelsServers()` enumerates all
   registered LuCLI server entries with a live PID (parsing the
   `<pid>:<port>` server.pid format and using `java.lang.ProcessHandle`
   for liveness without shelling out).
3. When there are running servers but none match the cwd, print a
   helpful list with each server's name + port + project path, plus
   the explicit syntax — `wheels server stop --name <name>` and
   `wheels server list` — that recovers from the orphan state without
   leaving the wheels CLI.

Verified end-to-end on macOS arm64:

  $ cd /tmp/parent       # not a Wheels project
  $ wheels stop
  Stopping Wheels server...

  No registered server matches this directory.
  Running Wheels servers:
    - repapp (port 9991, project /private/tmp/parent/repapp)

  To stop a specific server: wheels server stop --name <name>
  To list all servers:      wheels server list

Normal in-project `wheels stop` is unaffected — the registered-server
match short-circuits the orphan check and falls through to the regular
LuCLI delegation. CLI suite: 457 pass, 3 fail (pre-existing DoctorSpec
#2260, unrelated).

* fix(model): migrator emits symmetric DDL for empty default across string-like types

Closes fresh-VM journal F17. Before this PR, `addColumnOptions` in
`vendor/wheels/databaseAdapters/Abstract.cfc` had a special case for
`type='string'` with `default=""` that omitted the DEFAULT clause:

  } else if (arguments.options.type == 'string' && arguments.options.default eq "") {
      arguments.sql = arguments.sql;          // no DEFAULT clause
  } else {
      arguments.sql = arguments.sql & " DEFAULT ...";
  }

…but `text` and `char` columns fell through to the else branch and
emitted `DEFAULT ''`. So a migration that declared title and body
identically:

  t.string(columnNames="title", default="", allowNull=true, limit=255);
  t.text(columnNames="body",  default="", allowNull=true);

…produced asymmetric DDL. That asymmetry then interacted with
`validatesPresenceOf` — which checks the column's introspected
`hasDatabaseColumnDefault` and skips presence-check when a default
exists — making the user's `validatesPresenceOf` rule fire for `title`
(no DEFAULT clause emitted) but silently skip for `body` (DEFAULT ''
emitted). Tutorial chapter 7's model spec `requires a body` failed
because of this; an HTTP request that omits `post[body]` (vs sending
empty string) also slipped past validation.

Fix: extend the special case to cover all string-like types
(`string,text,char`). Empty default → no DEFAULT clause for all three;
explicit non-empty defaults still emit DEFAULT correctly.

Seven new specs in `addColumnOptionsSpec.cfc` cover:
- string/text/char with default="" all omit DEFAULT
- string/text with non-empty default still emit DEFAULT '<value>'
- integer with default="" still becomes DEFAULT NULL (regression for
  the existing typed-numeric branch)
- boolean with default=true still emits DEFAULT 1

All 7 pass; framework suite: 3340 pass, 0 fail (was 3333 before).

* fix(view): wheels-typed error pages set HTTP status (404 / 500), not 200

Closes #2319. Before this PR, when `$runOnError` rendered a
Wheels-typed exception (`Wheels.RouteNotFound`,
`Wheels.DataSourceNotFound`, `Wheels.ViewNotFound`, etc) in HTML
format, no `$header(statusCode = ...)` fired before the body was
written. Lucee defaulted to HTTP 200 — misleading anything monitoring,
caching, retrying, or alerting on status codes.

JSON and XML branches for non-Wheels exceptions had explicit
`$header(statusCode = 500)`; the Wheels-error branch and the JSON/XML
Wheels-error sub-branches all skipped status assignment.

This change adds a single mapping at the top of the wheelsError branch:

- Any `Wheels.*NotFound` (RouteNotFound, RecordNotFound, ViewNotFound,
  PackageNotFound, DataSourceNotFound, …) → 404
- Everything else → 500

The status is set before the body is written so the response header
commits at the right code regardless of when the servlet engine
flushes. `$throwErrorOrShow404Page` already calls $header(statusCode=404)
before throwing, but the onError flow can reset the response, so
re-asserting in $runOnError is the durable place.

Five new specs in onerrorSpec.cfc lock the mapping table — they mirror
the same regex used in EventMethods so a rename there breaks the
build immediately. Includes an explicit case for ActionParameterMissing
(Missing != NotFound, stays 500) to guard against a too-greedy regex
later.

Framework suite: 3347 pass, 0 fail (was 3333 before this PR's chain;
+7 from F17 specs, +7 from these new mappings). One pre-existing test
that hits an unknown route and expects 404 (testClientSpec
`assertNotFound() passes on 404 response`) still passes — Wheels.ViewNotFound
maps to 404 under the new rule.

Author: bpamiri

cli/lucli/Module.cfc

@@ -394,6 +394,31 @@ component extends="modules.BaseModule" {
 	 */
 	public string function stop() {
 		out("Stopping Wheels server...", "cyan");
+
+		// If LuCLI's stop won't find a registered server for this directory
+		// (cwd doesn't match any `.project-path`), enumerate the user's
+		// running servers and offer specific stop commands. Without this,
+		// `wheels stop` is silently a no-op when run from a parent dir, an
+		// unrelated dir, or after the project was moved/deleted — leaving
+		// orphan Java processes the user has to chase with `lsof`+`kill`.
+		// See GH #2316.
+		var match = $findServerForProject(variables.projectRoot);
+		if (!len(match)) {
+			var orphans = $listRunningWheelsServers();
+			if (arrayLen(orphans)) {
+				out("");
+				out("No registered server matches this directory.", "yellow");
+				out("Running Wheels servers:", "yellow");
+				for (var s in orphans) {
+					out("  - " & s.name & " (port " & s.port & ", project " & s.projectPath & ")");
+				}
+				out("");
+				out("To stop a specific server: wheels server stop --name <name>", "cyan");
+				out("To list all servers:      wheels server list", "cyan");
+				return "";
+			}
+		}
+
 		executeCommand("server", ["stop"], variables.projectRoot);
 		return "";
 	}
@@ -3750,6 +3775,101 @@ component extends="modules.BaseModule" {
 		}
 	}
 
+	/**
+	 * Look up the registered LuCLI server entry whose `.project-path`
+	 * matches the given project root. Returns the server name, or empty
+	 * string if no match. Used by stop() to detect when `wheels stop`
+	 * would be a no-op (not in a registered project dir) so we can offer
+	 * the user a list of running servers to target instead.
+	 */
+	private string function $findServerForProject(required string projectRoot) {
+		if (!len(arguments.projectRoot)) return "";
+		var lucliHome = $resolveLucliHome();
+		if (!len(lucliHome)) return "";
+		var serversDir = lucliHome & "/servers";
+		if (!directoryExists(serversDir)) return "";
+
+		var canonicalCwd = arguments.projectRoot;
+		try {
+			canonicalCwd = createObject("java", "java.io.File")
+				.init(arguments.projectRoot)
+				.getCanonicalPath();
+		} catch (any e) {}
+
+		var entries = directoryList(serversDir, false, "name");
+		for (var name in entries) {
+			var pp = serversDir & "/" & name & "/.project-path";
+			if (!fileExists(pp)) continue;
+			var registered = trim(fileRead(pp));
+			if (len(registered) && registered == canonicalCwd) {
+				return name;
+			}
+		}
+		return "";
+	}
+
+	/**
+	 * Enumerate LuCLI server registry entries that are currently running
+	 * (server.pid file present and pid is alive). Returns an array of
+	 * {name, port, projectPath} structs. Used by stop()'s no-match
+	 * recovery hint. Best-effort — entries we can't read cleanly are
+	 * silently skipped.
+	 */
+	private array function $listRunningWheelsServers() {
+		var result = [];
+		var lucliHome = $resolveLucliHome();
+		if (!len(lucliHome)) return result;
+		var serversDir = lucliHome & "/servers";
+		if (!directoryExists(serversDir)) return result;
+
+		var entries = directoryList(serversDir, false, "name");
+		for (var name in entries) {
+			var pidFile = serversDir & "/" & name & "/server.pid";
+			if (!fileExists(pidFile)) continue;
+			try {
+				// LuCLI writes "<pid>:<port>" into server.pid. Split off the
+				// pid; ignore the rest (port may be empty / different from
+				// the live socket).
+				var raw = trim(fileRead(pidFile));
+				var pid = listFirst(raw, ":");
+				var portFromPid = listLen(raw, ":") > 1 ? listGetAt(raw, 2, ":") : "";
+				if (!len(pid) || !isNumeric(pid)) continue;
+				if (!$isProcessAlive(pid)) continue;
+				var info = { name: name, port: portFromPid, projectPath: "?" };
+				var pp = serversDir & "/" & name & "/.project-path";
+				if (fileExists(pp)) info.projectPath = trim(fileRead(pp));
+				if (!len(info.port)) {
+					// Port wasn't in server.pid (older format) — try lucee.json.
+					var luceeJson = info.projectPath & "/lucee.json";
+					if (fileExists(luceeJson)) {
+						try {
+							var cfg = deserializeJSON(fileRead(luceeJson));
+							if (isStruct(cfg) && structKeyExists(cfg, "port")) info.port = cfg.port;
+						} catch (any e) {}
+					}
+				}
+				if (!len(info.port)) info.port = "?";
+				arrayAppend(result, info);
+			} catch (any e) {}
+		}
+		return result;
+	}
+
+	/**
+	 * True if the given POSIX pid is alive. Uses `kill -0` semantics via
+	 * Java's ProcessHandle (Java 9+) so we don't shell out.
+	 */
+	private boolean function $isProcessAlive(required string pid) {
+		try {
+			var ProcessHandle = createObject("java", "java.lang.ProcessHandle");
+			var optional = ProcessHandle.of(javaCast("long", arguments.pid));
+			if (optional.isPresent()) {
+				return optional.get().isAlive();
+			}
+		} catch (any e) {}
+		return false;
+	}
+
 	/**
 	 * Resolve the LuCLI home root. Order of resolution:
 	 *   1. $LUCLI_HOME if set (e.g. brew wrapper exports $HOME/.wheels).

vendor/wheels/databaseAdapters/Abstract.cfc

@@ -82,7 +82,17 @@ component extends="wheels.migrator.Base"{
 					arguments.sql = arguments.sql & " DEFAULT NULL";
 				} else if (arguments.options.type == 'boolean') {
 					arguments.sql = arguments.sql & " DEFAULT #IIf(arguments.options.default, 1, 0)#";
-				} else if (arguments.options.type == 'string' && arguments.options.default eq "") {
+				} else if (
+					arguments.options.default eq ""
+					&& ListFindNoCase("string,text,char", arguments.options.type)
+				) {
+					// Symmetric handling for all string-like types: an empty
+					// `default=""` means "no default clause" (not `DEFAULT ''`).
+					// Without this, `t.string("a", default="")` and
+					// `t.text("b", default="")` produced asymmetric DDL and
+					// the presence-check skip in validatesPresenceOf fired
+					// inconsistently between equivalent column types. See
+					// fresh-VM journal F17.
 					arguments.sql = arguments.sql;
 				} else {
 					arguments.sql = arguments.sql & " DEFAULT #quote(value = arguments.options.default, options = arguments.options)#";

vendor/wheels/events/EventMethods.cfc

@@ -68,6 +68,26 @@ component extends="wheels.Global" implements="wheels.interfaces.events.EventHand
 					}
 				}
 				if (StructKeyExists(local, "wheelsError")) {
+					// Map Wheels error types to HTTP status codes. Any
+					// `Wheels.*NotFound` (RouteNotFound, RecordNotFound,
+					// ViewNotFound, etc) is a 404; everything else is a 500.
+					// Set the status BEFORE writing the body so the response
+					// header is committed at the right code regardless of
+					// when the servlet engine flushes (HTML-format Wheels
+					// errors used to render with HTTP 200 because no
+					// $header(statusCode=...) fired before the body was
+					// written — see GH #2319). Note: $throwErrorOrShow404Page
+					// already calls $header(statusCode=404) before throwing,
+					// but onError reaches us via Application.cfc which can
+					// reset the response, so we re-assert the status here.
+					if (
+						StructKeyExists(local.wheelsError, "type")
+						&& ReFindNoCase("^Wheels\.[A-Za-z]*NotFound$", local.wheelsError.type)
+					) {
+						$header(statusCode = 404);
+					} else {
+						$header(statusCode = 500);
+					}
 					local.rv = "";
 					if (local.format == "json") {
 						$header(name = "Content-Type", value = "application/json");

vendor/wheels/tests/specs/events/onerrorSpec.cfc

@@ -17,6 +17,57 @@ component extends="wheels.WheelsTest" {
 				// and without :line suffix (template and line number are in separate HTML elements)
 				expect(actual).toInclude("onerrorSpec.cfc")
 			})
+
+			// Regression coverage for GH ##2319: Wheels-typed errors rendered
+			// in HTML format used to leave the status code at Lucee's default
+			// (200), misleading anything monitoring/alerting/retrying on
+			// status. The mapping (RouteNotFound/RecordNotFound → 404,
+			// everything else → 500) is mirrored from EventMethods.$runOnError;
+			// this spec freezes the contract so a rename there breaks the
+			// build immediately. Tested via a helper rather than a full
+			// onError invocation because $runOnError needs an active request
+			// scope and a real exception path that isn't easy to fake from
+			// inside a spec.
+			it("maps Wheels.RouteNotFound to HTTP 404 (##2319)", () => {
+				expect($expectedStatusFor("Wheels.RouteNotFound")).toBe(404)
+			})
+
+			it("maps Wheels.RecordNotFound to HTTP 404 (##2319)", () => {
+				expect($expectedStatusFor("Wheels.RecordNotFound")).toBe(404)
+			})
+
+			it("maps Wheels.ViewNotFound to HTTP 404 (##2319)", () => {
+				expect($expectedStatusFor("Wheels.ViewNotFound")).toBe(404)
+			})
+
+			it("maps Wheels.PackageNotFound to HTTP 404 (##2319)", () => {
+				// Any type ending in NotFound counts — futureproof against
+				// new not-found types without requiring an enum update.
+				expect($expectedStatusFor("Wheels.PackageNotFound")).toBe(404)
+			})
+
+			it("maps Wheels.DataSourceNotFound to HTTP 404 (##2319)", () => {
+				// DataSourceNotFound also matches the *NotFound rule. A
+				// missing datasource at the framework layer is closer to
+				// "configured resource missing" than a blanket server
+				// error, so 404 is the more honest status.
+				expect($expectedStatusFor("Wheels.DataSourceNotFound")).toBe(404)
+			})
+
+			it("maps a generic Wheels error type to HTTP 500 (##2319)", () => {
+				expect($expectedStatusFor("Wheels.UnknownThingHappened")).toBe(500)
+			})
+
+			it("maps Wheels.ActionParameterMissing to HTTP 500 (Missing != NotFound, ##2319)", () => {
+				expect($expectedStatusFor("Wheels.ActionParameterMissing")).toBe(500)
+			})
 		})
 	}
+
+	private numeric function $expectedStatusFor(required string wheelsType) {
+		if (ReFindNoCase("^Wheels\.[A-Za-z]*NotFound$", arguments.wheelsType)) {
+			return 404
+		}
+		return 500
+	}
 }

vendor/wheels/tests/specs/migrator/addColumnOptionsSpec.cfc

@@ -0,0 +1,78 @@
+/**
+ * Regression coverage for fresh-VM journal F17 — `addColumnOptions` emitted
+ * asymmetric DDL for `default=""` between string-like column types.
+ *
+ *   t.string(...,default="") → no DEFAULT clause
+ *   t.text(...,default="")   → DEFAULT ''
+ *   t.char(...,default="")   → DEFAULT ''
+ *
+ * That asymmetry then interacts with the presence-check skip in
+ * validatesPresenceOf (vendor/wheels/model/validations.cfc) — which checks
+ * whether the underlying column has a database default — making the user's
+ * `validatesPresenceOf` rule fire for `title` (string, no default emitted)
+ * but silently skip for `body` (text, DEFAULT '' emitted), even though
+ * the user wrote both columns identically. Tutorial chapter 7's model spec
+ * `requires a body` failed because of this.
+ *
+ * After the fix in Abstract.addColumnOptions, all three string-like types
+ * with `default=""` produce the same DDL (no DEFAULT clause). That lines
+ * the validatesPresenceOf skip up consistently.
+ */
+component extends="wheels.WheelsTest" {
+
+	function beforeAll() {
+		variables.adapter = createObject("component", "wheels.migrator.Migration").init().adapter;
+	}
+
+	private string function buildOptions(string type, string default = "", boolean allowNull = true) {
+		var opts = {
+			type: arguments.type,
+			default: arguments.default,
+			allowNull: arguments.allowNull
+		};
+		return variables.adapter.addColumnOptions(sql = "", options = opts);
+	}
+
+	function run() {
+
+		describe("addColumnOptions — symmetric default handling for string-like types (F17)", () => {
+
+			it("string with default='' omits the DEFAULT clause", () => {
+				var sql = buildOptions(type = "string", default = "");
+				expect(sql).notToInclude("DEFAULT");
+			});
+
+			it("text with default='' omits the DEFAULT clause (regression for F17)", () => {
+				var sql = buildOptions(type = "text", default = "");
+				expect(sql).notToInclude("DEFAULT");
+			});
+
+			it("char with default='' omits the DEFAULT clause (regression for F17)", () => {
+				var sql = buildOptions(type = "char", default = "");
+				expect(sql).notToInclude("DEFAULT");
+			});
+
+			it("string with a real default (non-empty) still emits DEFAULT", () => {
+				var sql = buildOptions(type = "string", default = "hello");
+				expect(sql).toInclude("DEFAULT");
+				expect(sql).toInclude("'hello'");
+			});
+
+			it("text with a real default (non-empty) still emits DEFAULT", () => {
+				var sql = buildOptions(type = "text", default = "long body");
+				expect(sql).toInclude("DEFAULT");
+				expect(sql).toInclude("'long body'");
+			});
+
+			it("integer with default='' becomes DEFAULT NULL (unchanged behavior)", () => {
+				var sql = buildOptions(type = "integer", default = "");
+				expect(sql).toInclude("DEFAULT NULL");
+			});
+
+			it("boolean with default=true emits DEFAULT 1 (unchanged behavior)", () => {
+				var sql = buildOptions(type = "boolean", default = true);
+				expect(sql).toInclude("DEFAULT 1");
+			});
+		});
+	}
+}