@thehammer/danx-dashboard-mcp 0.1.335 → 0.1.337

package/dist/index.js

@@ -88,7 +88,7 @@ import { READ_IDLE_TIMEOUT_MS } from "./listen.js";
 import { REQUEST_TIMEOUT_MS, realScheduleInterval, realSleep } from "./session-stream.js";
 import { servePlanEventsWait } from "./plan-events-tool.js";
 import { lookupRestartNotice, RESTART_NOTICE_ARGS } from "./restart-notice.js";
-import { stopWhenSessionEnds } from "./shutdown.js";
+import { makeSessionStop, stopWhenSessionEnds } from "./shutdown.js";
 import { SUBAGENTS_LIVE_SUBCOMMAND, runSubagentsLiveCommand } from "./subagents-live.js";
 import { resolveBootCredential } from "./credential.js";
 import { SessionKeyUnusableError, deleteSessionKey } from "./session-key.js";
@@ -866,10 +866,9 @@ async function main() {
     stopWhenSessionEnds({
         server: server.server,
         stdin: process.stdin,
-        stop: () => {
-            permissionWatch.stop();
-            return planEventRelay.close();
-        },
+        signals: process,
+        exit: (code) => process.exit(code),
+        stop: makeSessionStop(permissionWatch, planEventRelay),
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);

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.
@@ -152,9 +154,14 @@ export class PlanEventRelay {
             this.buffer = this.buffer.map((r) => ({ ...r, recent: boundedIds([...cursor.ids, ...r.recent]) }));
         }
         this.touch();
-        const switching = this.ensureReporter(args.transcriptPath);
-        if (switching !== null)
-            await switching;
+        this.ensureReporter(args.transcriptPath);
+        // DX-5415 / DX-4233: a transcript switch's settle rides `settling` (the chain a suspend uses), so every call paused on it resumes in call order and the older one cannot overwrite the newer call's waiter.
+        if (this.settling !== null) {
+            await this.settling;
+            // 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 +192,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();
     }
@@ -277,8 +285,12 @@ export class PlanEventRelay {
     }
     /** Creates the heartbeat reporter on the first call; a later call's transcript path (a resumed session) is handed to it. */
     ensureReporter(transcriptPath) {
-        if (this.reporter !== null)
-            return this.reporter.useTranscript(transcriptPath);
+        if (this.reporter !== null) {
+            const switching = this.reporter.useTranscript(transcriptPath);
+            if (switching !== null)
+                this.chainSettling(switching);
+            return;
+        }
         this.reporter = new HeartbeatReporter({
             auth: () => {
                 const auth = this.deps.auth();
@@ -295,7 +307,14 @@ export class PlanEventRelay {
             announce: (text, source) => this.digest.route({ type: "event", id: null, text, origin: null, scope: "session", urgent: isUrgent({ source }) }),
             forceReconnect: () => this.run?.forceReconnect?.(),
         }, transcriptPath ?? null);
-        return null;
+    }
+    /** DX-5415: the one settle chain: the last settle and `stopping` both finish before it clears itself. */
+    chainSettling(stopping) {
+        const settling = Promise.all([this.settling, stopping]).then(() => {
+            if (this.settling === settling)
+                this.settling = null;
+        });
+        this.settling = settling;
     }
     /** Mark the relay in use and make sure the heartbeat is scheduled. */
     touch() {
@@ -339,13 +358,8 @@ export class PlanEventRelay {
         this.run = null;
         // DX-5415: the reporter's stop settles its collector's held sub-agent finals first; callers that can wait (shutdown, the next call) do.
         const stopping = this.reporter?.stop() ?? null;
-        if (stopping !== null) {
-            const settling = Promise.all([this.settling, stopping]).then(() => {
-                if (this.settling === settling)
-                    this.settling = null;
-            });
-            this.settling = settling;
-        }
+        if (stopping !== null)
+            this.chainSettling(stopping);
         this.reporter = null;
         this.digest.reset();
         this.dropPlanScoped();

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,37 @@
  * 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. The handler is `once` per signal: a second signal of the
+ * SAME kind takes the default action, but a DIFFERENT one (SIGTERM then SIGINT) runs the handler again, which is safe because
+ * `stop` is idempotent. The settle is bounded (10 s), yet a parent that signals with an SDK client allows only about 4 s before
+ * it sends SIGKILL, so the held finals are stored best-effort within that window, not guaranteed.
  */
 export function stopWhenSessionEnds(wiring) {
     wiring.server.onclose = wiring.stop;
     wiring.stdin.once("end", wiring.stop);
+    const exitAfterStop = () => {
+        // A synchronous throw from `stop` takes the same "shutdown failed" path as a rejection.
+        void Promise.resolve().then(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);
+}
+/**
+ * DX-5415: the server's stop callback, the one link from every shutdown trigger to the relay's settle: it returns the relay's
+ * pending `close()` so a signal handler can wait for it before exiting.
+ */
+export function makeSessionStop(permissionWatch, planEventRelay) {
+    return () => {
+        permissionWatch.stop();
+        return planEventRelay.close();
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.335",
+  "version": "0.1.337",
   "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",