@thehammer/danx-dashboard-mcp 0.1.322 → 0.1.323

package/dist/http-client.js

@@ -1,6 +1,13 @@
-import { boardStampOf } from "./route-board-scope.js";
+import { boardStampOf, takesBoardInBody } from "./route-board-scope.js";
 import { assertVersionFloorSatisfied, MCP_MIN_VERSION_HEADER } from "./version-floor.js";
 import { PLUGIN_BACKGROUND_HEADER } from "./session-options.js";
+/** `<basePath><path>` with the path's own query string cut off and its leading slash normalised (an empty or "/" path adds nothing). */
+function routePathOf(path, basePath = "/api/issues") {
+    const [rawPath] = path.split("?", 2);
+    if (rawPath === "" || rawPath === "/")
+        return basePath;
+    return `${basePath}${rawPath.startsWith("/") ? rawPath : `/${rawPath}`}`;
+}
 export class DashboardHttpClient {
     config;
     fetchImpl;
@@ -71,7 +78,7 @@ export class DashboardHttpClient {
         }
         else if (args.body !== undefined) {
             headers["Content-Type"] = "application/json";
-            payload = JSON.stringify(args.body);
+            payload = JSON.stringify(this.withBodyBoard(args));
         }
         let res;
         try {
@@ -116,31 +123,44 @@ export class DashboardHttpClient {
         }
         return { ok: false, status: res.status, body: parsed };
     }
+    /**
+     * DX-5337 - the body of a request whose route reads the board from `body.board` (issue create/import): the board the caller wrote is kept;
+     * with none, the call's `board` argument or the dispatch's board is filled in. DX-3465 deleted the per-operation `issue_create` tool that
+     * put the dispatch's board in the body, and the create route does not read `?board=`, so a dispatched agent's create arrived with no board
+     * and was refused 400. A board-less server with no `board` argument fills nothing: the dashboard's own 400 names the missing board.
+     */
+    withBodyBoard(args) {
+        const body = args.body;
+        if (!takesBoardInBody(args.method, routePathOf(args.path, args.basePath)))
+            return body;
+        if (typeof body !== "object" || body === null || Array.isArray(body))
+            return body;
+        if (body.board !== undefined)
+            return body;
+        const board = args.board ?? this.config.board;
+        return board === undefined ? body : { ...body, board };
+    }
     buildUrl(method, path, extraQuery, boardOverride, basePath = "/api/issues") {
         const base = this.config.baseUrl.replace(/\/+$/, "");
-        const [rawPath, existingQs] = path.split("?", 2);
-        let cleanPath;
-        if (rawPath === "" || rawPath === "/") {
-            cleanPath = "";
-        }
-        else {
-            cleanPath = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
-        }
+        const [, existingQs] = path.split("?", 2);
         const params = new URLSearchParams(existingQs ?? "");
         // DX-3750 / DX-4303 — only a route the dashboard takes `?board=` on gets the stamp; see `route-board-scope.ts`.
         // DX-4542 — a route whose board is OPTIONAL (no board = the whole team) gets only the board the caller named: stamping the dispatch's
         // board there would make the team-wide list impossible to ask for.
-        const stamp = boardStampOf(method, `${basePath}${cleanPath}`);
-        if (stamp === "stamp") {
+        const routePath = routePathOf(path, basePath);
+        const stamp = boardStampOf(method, routePath);
+        // DX-5337: issue create/import take the board in the body only (`withBodyBoard`), so no `?board=` rides them: one path, never two.
+        const boardInQuery = !takesBoardInBody(method, routePath);
+        if (boardInQuery && stamp === "stamp") {
             const board = boardOverride ?? this.config.board;
             // DX-4592: a board-less server (the danxbot plugin's, no DANX_REPO_NAME/DANXBOT_BOARD_NAME) stamps nothing when the call names no
-            // board. Whether the route NEEDS one is the dashboard's to say: a route that does (issue create/import, quality-gate and settings
-            // routes, the dispatch verbs) answers 400 naming `board`, while a card-id, plan or plan-session route takes its board from the card
+            // board. Whether the route NEEDS one is the dashboard's to say: a route that does (quality-gate and settings routes, the dispatch
+            // verbs) answers 400 naming `board`, while a card-id, plan or plan-session route takes its board from the card
             // or the plan. Refusing here (DX-4555) wrongly stopped every plan route, `plan_connect` first.
             if (board !== undefined)
                 params.set("board", board);
         }
-        else if (stamp === "named" && boardOverride !== undefined) {
+        else if (boardInQuery && stamp === "named" && boardOverride !== undefined) {
             params.set("board", boardOverride);
         }
         if (extraQuery) {
@@ -163,6 +183,6 @@ export class DashboardHttpClient {
             }
         }
         const query = params.toString();
-        return `${base}${basePath}${cleanPath}${query === "" ? "" : `?${query}`}`;
+        return `${base}${routePath}${query === "" ? "" : `?${query}`}`;
     }
 }

package/dist/route-board-scope.generated.js

@@ -61,3 +61,8 @@ export const GET_ROUTE_BOARD_SCOPE = [
     ["/api/worker/dispatches/recent-signal-failures", "refuse"],
     ["/api/workers", "refuse"],
 ];
+/** DX-5337 - the routes that read the card's board from `body.board` only: the client fills a dispatch's board in there and sends no `?board=`. */
+export const BODY_BOARD_ROUTES = [
+    ["POST", "/api/issues"],
+    ["POST", "/api/issues/import"],
+];

package/dist/route-board-scope.js

@@ -11,7 +11,7 @@
  * Only GET routes are listed - the server refuses an unknown query key on a read alone - so every other method takes the key. A
  * GET path no template matches takes it too: the server answers it with a 404 whatever the query.
  */
-import { GET_ROUTE_BOARD_SCOPE } from "./route-board-scope.generated.js";
+import { BODY_BOARD_ROUTES, GET_ROUTE_BOARD_SCOPE } from "./route-board-scope.generated.js";
 const RANK = { literal: 2, param: 1, rest: 0 };
 function compile(template, stamp) {
     const segments = template
@@ -55,3 +55,17 @@ export function boardStampOf(method, routePath) {
     const parts = routePath.slice(1).split("/");
     return ROUTES.find((route) => matches(route, parts))?.stamp ?? "stamp";
 }
+/**
+ * DX-5337 - the routes that read the card's board ONLY from `body.board` (issue create and import), from the generated
+ * `BODY_BOARD_ROUTES` (the server's `RouteDef.boardInBody`). A dispatch's default board reaches them through the body and through
+ * nothing else: the client fills `body.board` when the caller named none and sends no `?board=` there.
+ */
+const BODY_BOARD = BODY_BOARD_ROUTES.map(([method, template]) => ({
+    method,
+    route: compile(template, "stamp"),
+}));
+/** Whether `<method> <routePath>` (no query string) takes its board in `body.board`. */
+export function takesBoardInBody(method, routePath) {
+    const parts = routePath.replace(/\/+$/, "").slice(1).split("/");
+    return BODY_BOARD.some((entry) => entry.method === method && matches(entry.route, parts));
+}

package/package.json

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