@thehammer/danx-dashboard-mcp 0.1.336 → 0.1.338

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";
@@ -868,10 +868,7 @@ async function main() {
         stdin: process.stdin,
         signals: process,
         exit: (code) => process.exit(code),
-        stop: () => {
-            permissionWatch.stop();
-            return planEventRelay.close();
-        },
+        stop: makeSessionStop(permissionWatch, planEventRelay),
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/plan-events-relay.js

@@ -115,7 +115,7 @@ export class PlanEventRelay {
     lastActivityAt = 0;
     heartbeat = null;
     reporter = null;
-    /** DX-5415: the stop of the last suspended reporter (its final settle); resolved when none is running. */
+    /** DX-5415: the chain of every reporter stop still storing held finals (a suspend's and a transcript switch's); null when none is pending. Never rejects (see `chainSettling`). */
     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;
@@ -154,10 +154,11 @@ 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;
-            // 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.
+        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: [] };
         }
@@ -175,6 +176,8 @@ export class PlanEventRelay {
             this.start(cursor);
         if (this.buffer.length > 0)
             return this.answer();
+        // DX-5415 / DX-4233: supersede where the waiter is installed, not before the pauses: calls resume in call order, so the newest always holds the slot and an older one that resumed late cannot orphan the waiter beneath it.
+        this.supersedeWaiter();
         return new Promise((resolve) => {
             const onAbort = () => this.supersedeWaiter();
             signal?.addEventListener("abort", onAbort, { once: true });
@@ -284,8 +287,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();
@@ -302,7 +309,18 @@ 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.
+     * `stopping` never rejects (a reporter's stop settles its own failures), so `settling` never rejects and
+     * every waiter on it resumes; do not add a swallowing fallback here.
+     */
+    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() {
@@ -346,13 +364,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/shutdown.js

@@ -8,14 +8,17 @@
  *
  * 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.
+ * 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 = () => {
-        void Promise.resolve(wiring.stop()).then(() => wiring.exit(0), (err) => {
+        // 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);
         });
@@ -23,3 +26,13 @@ export function stopWhenSessionEnds(wiring) {
     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.336",
+  "version": "0.1.338",
   "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",