monomind 2.7.9 → 2.7.11

package/packages/@monomind/cli/bin/cli.js

@@ -264,13 +264,72 @@ if (isMCPMode) {
     }
     process.exit(1);
   };
+  // Not every uncaught error is a bug in monomind, and filing a PUBLIC GitHub
+  // issue for one that isn't is worse than useless — it leaks the user's paths
+  // into a tracker and buries real crashes in noise. Two classes are user
+  // environment or normal usage, never a product defect:
+  //
+  //   EPIPE / ERR_STREAM_DESTROYED — the reader closed the pipe first. This is
+  //     what `monomind hooks worker list | head` does every single time, and
+  //     what `| less` does when you quit early. Completely normal (issue #41).
+  //
+  //   ERR_MODULE_NOT_FOUND — a dependency is missing from the install: a
+  //     partial/corrupt node_modules, or the CLI being run straight out of an
+  //     extracted tarball. The user needs an actionable message, not a bug
+  //     report filed on their behalf (issues #46, #47).
+  //
+  // Anything else still reports as before.
+  const classifyFault = (err) => {
+    const code = err && err.code;
+    if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') return 'broken-pipe';
+    if (code === 'ERR_MODULE_NOT_FOUND') return 'missing-dependency';
+    return 'crash';
+  };
+
+  /** Handles the non-bug classes. Returns true if it fully handled the error. */
+  const handleExpectedFault = (err) => {
+    switch (classifyFault(err)) {
+      case 'broken-pipe':
+        // Downstream went away — there is nothing left to say and nowhere to
+        // say it. Exiting 0 keeps `monomind ... | head` from looking failed.
+        process.exit(0);
+        return true;
+      case 'missing-dependency': {
+        const pkg = /Cannot find package '([^']+)'/.exec(safeMsg(err && err.message))?.[1];
+        console.error(
+          pkg
+            ? `[monomind] Missing dependency: ${pkg}\n` +
+                `  This is an install problem, not a crash — nothing was reported.\n` +
+                `  Try: npm install ${pkg}   (or reinstall monomind: npm i -g monomind@latest)`
+            : `[monomind] A dependency could not be resolved: ${safeMsg(err && err.message)}\n` +
+                `  This is an install problem, not a crash — nothing was reported.`,
+        );
+        if (process.env.DEBUG) console.error(err && err.stack);
+        process.exit(1);
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+
+  // Belt and braces for the pipe case: handling 'error' on the streams keeps a
+  // mid-write EPIPE from becoming an uncaughtException at all.
+  for (const stream of [process.stdout, process.stderr]) {
+    stream.on('error', (err) => {
+      if (classifyFault(err) === 'broken-pipe') process.exit(0);
+    });
+  }
+
   process.on('uncaughtException', (err) => {
+    if (handleExpectedFault(err)) return;
     console.error(`[${new Date().toISOString()}] FATAL [monomind] uncaughtException: ${safeMsg(err && err.message)}`);
     if (process.env.DEBUG) console.error(err && err.stack);
     reportAndExit(safeMsg(err && err.message) || 'uncaughtException', err && err.stack);
     return;
   });
   process.on('unhandledRejection', (reason) => {
+    if (reason instanceof Error && handleExpectedFault(reason)) return;
     const msg = reason instanceof Error ? reason.message : String(reason);
     console.error(`[${new Date().toISOString()}] FATAL [monomind] unhandledRejection: ${safeMsg(msg)}`);
     if (process.env.DEBUG && reason instanceof Error) console.error(reason.stack);

package/packages/@monomind/cli/dist/src/commands/org.js

@@ -300,6 +300,49 @@ const serveAction = async (ctx) => {
     };
     process.on('uncaughtException', (err) => { crashExit('uncaughtException', err); process.exit(1); });
     process.on('unhandledRejection', (err) => { crashExit('unhandledRejection', err); process.exit(1); });
+    // Termination diagnostics (#45). The two handlers above only cover errors
+    // raised *inside* the daemon. A report of the daemon vanishing after hours
+    // had a log holding nothing but its startup lines, because the ways a daemon
+    // usually dies were all unhandled:
+    //
+    //   - a signal (SIGTERM from a supervisor/OS, SIGHUP when a terminal closes)
+    //   - the event loop simply draining, which exits 0 and says nothing at all
+    //
+    // Both now announce themselves. Note what this deliberately cannot cover:
+    // SIGKILL, which is what the OOM killer sends, is uncatchable by design — no
+    // in-process handler can ever log it. That case is instead made *inferable*:
+    // every shutdown path below prints a terminal line, so a log that starts and
+    // then stops with no such line means the process was killed from outside
+    // (OOM being the usual culprit, and the reporter's org logs did show memory
+    // pressure). Absence of a shutdown line is now evidence, not ambiguity.
+    let shuttingDown = false;
+    const announceExit = (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            console.error(`[org serve] shutting down: ${reason}`);
+        }
+        catch { /* stderr gone */ }
+    };
+    for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+        process.on(sig, () => {
+            announceExit(`received ${sig}`);
+            try {
+                daemon.persistCrashStateAll();
+                daemon.clearHeartbeat();
+            }
+            catch { /* best effort */ }
+            // A daemon holds ref'd timers, so it will not drain on its own; an
+            // explicit exit is required here and is the intended signal semantics.
+            process.exit(sig === 'SIGTERM' || sig === 'SIGINT' ? 0 : 1);
+        });
+    }
+    process.on('exit', (code) => {
+        // Last word on the way out. Reached for the "event loop drained" case,
+        // which previously produced a completely silent disappearance.
+        announceExit(`process exiting with code ${code}`);
+    });
     // Heartbeat: write every 30s so `org status` can tell "alive but busy" from
     // "daemon gone" without relying on pid liveness alone.
     daemon.writeHeartbeat();