@whoz-oss/coday-web 0.0.0-workstream-forge.205 → 0.0.0-workstream-forge.207

package/index.js

@@ -4,7 +4,17 @@ import { dirname, resolve } from 'path';
 import { existsSync } from 'fs';
 import { spawn, spawnSync } from 'child_process';
 import { createRequire } from 'module';
-import { chooseMode, nxArgs, nxEnv, parseWorkspaceDir, resolveConfigDir, serverArgs } from './launcher.js';
+import {
+  chooseMode,
+  nxArgs,
+  nxEnv,
+  parseWorkspaceDir,
+  resolveConfigDir,
+  serverArgs,
+  shouldRunDoctor,
+  wantsDoctorOnly,
+  withoutCommand,
+} from './launcher.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -17,6 +27,9 @@ const __dirname = dirname(__filename);
  *    bundled `nx` on it, so the server, AgentOS and the Factory each get their own pane and log file.
  * 3. No TTY (desktop apps), --managed or CODAY_NO_NX=1: runs everything inside the server process,
  *    exactly like before (it still prints `Server is running on http://localhost:PORT`).
+ *
+ * Before 2, it runs the `doctor` preflight (implemented in the bundled server, nothing duplicated here) so that a
+ * missing Java or an unwritable config directory is said in plain scrollback, not inside an Nx pane that scrolls away.
  */
 
 // Create require function for resolving packages
@@ -151,7 +164,43 @@ function runNx() {
   return undefined;
 }
 
+/**
+ * The exit code `doctor` uses for "a check blocks the start" (DOCTOR_BLOCKED_EXIT in
+ * apps/server/src/lib/runtime/doctor.ts). It is deliberately not 1: that is what the server exits with on any
+ * unhandled error, and a preflight that merely crashed must never be what stops Coday.
+ */
+const DOCTOR_BLOCKED_EXIT = 2;
+
+/** Run the bundled server's `doctor`, inheriting the terminal so it prints its own report. */
+function runDoctor(argv) {
+  return spawnSync(process.execPath, [serverMainPath, 'doctor', ...serverArgs(argv)], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+}
+
+/**
+ * Preflight before the Nx TUI takes the terminal. Only a genuine blocker stops the start; anything else (a spawn
+ * error, a signal, a crash of the preflight itself) warns and carries on, like `runNx` falls back when the
+ * `workspace` command fails.
+ */
+function preflight() {
+  if (!shouldRunDoctor({ mode, argv: rawArgs, env: process.env })) return;
+  const result = runDoctor(rawArgs);
+  if (result.status === 0) return;
+  if (result.status === DOCTOR_BLOCKED_EXIT) process.exit(result.status);
+  const why = result.error?.message ?? (result.signal ? `killed by ${result.signal}` : `exit code ${result.status}`);
+  console.warn(`Preflight could not run (${why}): starting anyway.`);
+}
+
+// `coday-web doctor`: the report is the whole job, whatever the terminal is.
+if (wantsDoctorOnly(rawArgs)) {
+  const result = runDoctor(withoutCommand(rawArgs));
+  process.exit(result.error ? 1 : (result.status ?? 1));
+}
+
 console.log(`Coday Web: ${mode} mode (${reason})`);
+preflight();
 (mode === 'nx' ? Promise.resolve().then(runNx) : runManaged()).catch((error) => {
   console.error('Failed to start server:', error);
   process.exit(1);

package/launcher.js

@@ -34,9 +34,44 @@ export function resolveConfigDir(argv, home = homedir()) {
   return join(home, '.coday');
 }
 
-/** The arguments the server must see: the launcher's own (`--managed`) are removed. */
+/** Flags the launcher handles itself; the server never sees them. Both `--flag` and `--flag=value` forms. */
+const LAUNCHER_FLAGS = ['--managed', '--skip-doctor'];
+
+const hasFlag = (argv, flag) => argv.some((a) => a === flag || a.startsWith(`${flag}=`));
+
+/** The arguments the server must see: the launcher's own are removed. */
 export function serverArgs(argv) {
-  return argv.filter((a) => a !== '--managed');
+  return argv.filter((a) => !LAUNCHER_FLAGS.some((flag) => a === flag || a.startsWith(`${flag}=`)));
+}
+
+/**
+ * `coday-web doctor`: run the preflight and nothing else. Same rule as the bundled server's `parseCommand` (the
+ * first positional wins), so the command means the same thing with or without a terminal — without this the Nx
+ * branch would print the report and then start the whole stack, which is not what anyone typing `doctor` wants.
+ */
+export function wantsDoctorOnly(argv) {
+  return argv.find((a) => !a.startsWith('-')) === 'doctor';
+}
+
+/** The same arguments without that leading command word, so it is not handed to the server twice. */
+export function withoutCommand(argv) {
+  const at = argv.findIndex((a) => !a.startsWith('-'));
+  return at === -1 ? argv : [...argv.slice(0, at), ...argv.slice(at + 1)];
+}
+
+/**
+ * Whether to run the `doctor` preflight before starting.
+ *
+ * Only in `nx` mode, and for one reason: the Nx TUI is about to take the terminal, so a blocking problem must be said
+ * in plain scrollback first. The managed mode is the desktop apps, which have their own installer and show the same
+ * facts in the first-run wizard, so they are left alone (and spared the extra process).
+ *
+ * `--skip-doctor` / `CODAY_SKIP_DOCTOR=1` bypasses it, for anyone who knows better than the checks.
+ */
+export function shouldRunDoctor({ mode, argv, env }) {
+  if (mode !== 'nx') return false;
+  if (hasFlag(argv, '--skip-doctor')) return false;
+  return !(env.CODAY_SKIP_DOCTOR === '1' || env.CODAY_SKIP_DOCTOR === 'true');
 }
 
 /** Marker the server's `workspace` command prints before the directory it generated. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whoz-oss/coday-web",
-  "version": "0.0.0-workstream-forge.205",
+  "version": "0.0.0-workstream-forge.207",
   "repository": "https://github.com/whoz-oss/coday",
   "type": "module",
   "bin": {
@@ -13,9 +13,12 @@
   ],
   "dependencies": {
     "nx": "23.1.1",
-    "@whoz-oss/coday-client": "0.0.0-workstream-forge.205",
-    "@whoz-oss/coday-factory-cockpit": "0.0.0-workstream-forge.205",
-    "@whoz-oss/coday-server": "0.0.0-workstream-forge.205"
+    "@whoz-oss/coday-client": "0.0.0-workstream-forge.207",
+    "@whoz-oss/coday-factory-cockpit": "0.0.0-workstream-forge.207",
+    "@whoz-oss/coday-server": "0.0.0-workstream-forge.207"
+  },
+  "engines": {
+    "node": ">=22"
   },
   "publishConfig": {
     "access": "public"