@thehammer/danx-dashboard-mcp 0.1.335 → 0.1.336

package/dist/index.js

@@ -866,6 +866,8 @@ async function main() {
     stopWhenSessionEnds({
         server: server.server,
         stdin: process.stdin,
+        signals: process,
+        exit: (code) => process.exit(code),
         stop: () => {
             permissionWatch.stop();
             return planEventRelay.close();

package/dist/plan-events-relay.js

@@ -117,6 +117,8 @@ export class PlanEventRelay {
     reporter = null;
     /** DX-5415: the stop of the last suspended reporter (its final settle); resolved when none is running. */
     settling = null;
+    /** DX-5415: set by `close()` (the server's shutdown) and never cleared: a call paused across the close, or made after it, answers empty and starts nothing. */
+    closed = false;
     digest = new DigestHold((event) => this.accept(event));
     constructor(deps) {
         this.deps = deps;
@@ -126,12 +128,12 @@ export class PlanEventRelay {
         // Parsed first: a cursor this server did not issue is refused before it changes anything.
         const cursor = args.cursor === null ? null : parseCursor(args.cursor);
         // DX-4233: a request already cancelled (a plugin reload) touches nothing and starts nothing.
-        if (signal?.aborted)
+        if (signal?.aborted || this.closed)
             return { events: [] };
         // DX-5415: a suspend still storing the old collector's held finals ends before this call starts a new one (bounded inside).
         if (this.settling !== null) {
             await this.settling;
-            if (signal?.aborted)
+            if (signal?.aborted || this.closed)
                 return { events: [] };
         }
         // DX-4233: one wait at a time; the older call answers empty so its caller is never left hanging.
@@ -153,8 +155,12 @@ export class PlanEventRelay {
         }
         this.touch();
         const switching = this.ensureReporter(args.transcriptPath);
-        if (switching !== null)
+        if (switching !== null) {
             await switching;
+            // DX-5415 / DX-4233: the pause let a close() or a cancel through; a close already let go of the stream, heartbeat and reporter, so none is started again.
+            if (signal?.aborted || this.closed)
+                return { events: [] };
+        }
         this.buffer = this.buffer.filter((r) => !acknowledged(r.seq, cursor));
         if (this.pendingStop !== null) {
             const stopped = this.pendingStop;
@@ -185,6 +191,7 @@ export class PlanEventRelay {
     }
     /** Stop everything: the pending call, the stream, the heartbeat, the transcript tailer. For the server's shutdown. */
     close() {
+        this.closed = true;
         this.supersedeWaiter();
         return this.suspend();
     }

package/dist/session-stats.js

@@ -101,7 +101,7 @@ export class OperatorSessionStats {
     /** One collector flush carried by `send`; a refused or unlanded batch throws inside the collector, which re-queues it. */
     async flushVia(send) {
         const outcome = { carried: false, landed: true, planless: false };
-        await this.usage.flush({
+        const flushed = await this.usage.flush({
             applyStats: async (_dispatchId, payload) => {
                 outcome.carried = true;
                 const answer = await send(payload);
@@ -119,15 +119,17 @@ export class OperatorSessionStats {
                 return answer.stats;
             },
         }, OPERATOR_DISPATCH_REF);
-        return outcome;
+        return { ...outcome, outcome: flushed };
     }
     /**
      * Stop tailing. Idempotent; a stopped collector never starts again.
      *
      * DX-5415: a sub-agent's final report is held until its end signal is read, and confirmed only by a LATER poll (DX-5413), so a bare
      * `watcher.stop()` lost any final still held or whose signal was read in the last poll. A collecting watcher is therefore settled first:
-     * `drainFinal()`, then one flush carried by `send`, and only then stopped. The settle is bounded by `bound` (shutdown must not hang
-     * on a slow dashboard); a drain or flush that fails or is cut off costs only what it had not yet delivered, said on stderr.
+     * `drainFinal()`, then one flush carried by `send`, and only then stopped. The bound only stops WAITING: when it fires, `stop` returns
+     * and stops the watcher, but the drain and the flush already under way keep running to their own end (each dashboard request is
+     * bounded by its own request timeout), so shutdown never hangs and a cut-off settle can still land late. A drain that throws, a flush
+     * that fails or is refused, or a settle cut off costs only what it had not yet delivered, said on stderr.
      */
     async stop(send, bound) {
         if (this.stopped)
@@ -145,7 +147,11 @@ export class OperatorSessionStats {
         try {
             const settled = (async () => {
                 await watcher.drainFinal();
-                await this.flushVia(send);
+                // DX-5415: a failed or refused flush re-queues nothing for a collector that is stopping, so it says what it costs.
+                const flushed = (await this.flushVia(send)).outcome;
+                if (flushed !== "ok")
+                    process.stderr.write(`operator session stats: the final flush was ${flushed}; held sub-agent finals may be lost
+`);
                 return "settled";
             })();
             settled.catch(() => undefined); // a cut-off settle's late failure is already reported by the race below

package/dist/shutdown.js

@@ -2,11 +2,24 @@
  * DX-4523 / DX-4233 - what the server lets go of when its session ends: the permission watch's open stream and the plan event
  * relay (its pending call, stream, heartbeat and tailer), so nothing keeps the process alive after the client is gone.
  *
- * Two triggers, both needed: the transport's `onclose` (an orderly close of the connection) and the end of stdin. The SDK's stdio
- * transport does not watch stdin for its end (only a transport `close()` reaches `onclose`), so a client that simply exits
- * would leave the process running without the second one.
+ * Three triggers, all needed: the transport's `onclose` (an orderly close of the connection), the end of stdin (the SDK's stdio
+ * transport does not watch stdin for its end, so a client that simply exits would leave the process running without it), and a
+ * SIGTERM / SIGINT.
+ *
+ * DX-5415: `stop` returns the relay's bounded final settle (a sub-agent's held final report is stored before the collector stops).
+ * The first two triggers leave the process to end on its own once nothing keeps it alive, so the settle completes. A signal would
+ * kill it mid-settle, so its handler awaits `stop` and only then exits. `once`: a second signal finds no listener and takes the
+ * default action, the way out when the settle is slow.
  */
 export function stopWhenSessionEnds(wiring) {
     wiring.server.onclose = wiring.stop;
     wiring.stdin.once("end", wiring.stop);
+    const exitAfterStop = () => {
+        void Promise.resolve(wiring.stop()).then(() => wiring.exit(0), (err) => {
+            process.stderr.write(`danx-dashboard-mcp: shutdown failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            wiring.exit(1);
+        });
+    };
+    wiring.signals.once("SIGTERM", exitAfterStop);
+    wiring.signals.once("SIGINT", exitAfterStop);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.335",
+  "version": "0.1.336",
   "description": "Stdio MCP server fronting danxbot's dashboard API for agents (operator sessions and dispatched workers alike): the generic danxbot_api/danxbot_api_list/danxbot_api_spec tools reach any route the caller's credential may call, plus dedicated agent-specific tools (plan_connect, request_permission, attach_file, and danxbot_slack_reply) (DX-3465, PLN-11 R-25).",
   "license": "MIT",
   "type": "module",