@thehammer/danx-dashboard-mcp 0.1.214 → 0.1.215

package/dist/handlers.js

@@ -52,6 +52,18 @@ const PLAN_SESSIONS_BASE_PATH = "/api/plan-sessions";
  * only when the caller supplied one; the server leaves an unset title alone.
  */
 export async function planConnect(client, args) {
+    if (args.disconnect === true) {
+        if (args.title !== undefined) {
+            return { ok: false, status: 400, body: { error: "plan_connect: `disconnect: true` takes no `title` — a leave changes no title" } };
+        }
+        // DX-2985 — `DELETE /api/plan-sessions/me/plan?plan_id=`: `me` is the forwarded session id, so only the caller's own session leaves.
+        return client.request({
+            method: "DELETE",
+            path: "/me/plan",
+            basePath: PLAN_SESSIONS_BASE_PATH,
+            query: { plan_id: args.plan_id },
+        });
+    }
     return client.request({
         method: "POST",
         path: "/me/plan",

package/dist/http-client.js

@@ -1,5 +1,65 @@
-import { isBoardScopedRoute } from "./route-board-scope.js";
 import { assertVersionFloorSatisfied, MCP_MIN_VERSION_HEADER } from "./version-floor.js";
+/**
+ * DX-3750 — route-path prefixes (`<basePath><path>`, BEFORE any query
+ * string) that are NEVER board-scoped: the dashboard route serving them
+ * takes no `?board=` at all — either because the resource is GLOBAL
+ * (plans — see `plan_list`'s own doc: "Plans are GLOBAL, not board-scoped")
+ * or because it scopes some other way a `board` param would be meaningless
+ * for (dispatches scope by `repo`; a board resolves from a PATH segment on
+ * every route but its own list, which itself scopes by `repo`; `/api/routes`
+ * and `/api/openapi` are cross-board discovery). Server-side, each of these
+ * families' LIST route validates its query params with its own
+ * `rejectUnknownParams(params, TOP_LEVEL_..._PARAM_KEYS)` allowlist
+ * (`src/issues/plans-routes.ts`, `src/dashboard/dispatches-routes.ts`,
+ * `src/issues/boards-routes.ts`) — none of those allowlists names `board`
+ * (DX-3725), so stamping it 400s. THIS list and `NON_BOARD_SCOPED_PATH_PATTERNS` below are the only
+ * classification; `isBoardScopedRoute` is the one function that reads them — no second, independently-drifting
+ * copy anywhere else in this package.
+ *
+ * Deliberately prefix-matched, not exact-matched: every sub-route of a
+ * non-board-scoped family (`/api/plans/:id/cards`, `/api/boards/:id/export`,
+ * `/api/dispatches/:id/logs`, …) is equally never board-scoped — a plan, a
+ * dispatch and a board-export all resolve their target from a PATH segment
+ * or a `repo`/global scope, never from `?board=`.
+ */
+const NON_BOARD_SCOPED_PATH_PREFIXES = [
+    "/api/plans",
+    "/api/dispatches",
+    "/api/boards",
+    "/api/routes",
+    "/api/openapi",
+    // DX-4261: install- or team-global families, whose list reads declare no `board` (the engine 400s an unknown key).
+    "/api/team",
+    "/api/users",
+    "/api/account",
+    "/api/platform",
+    "/api/failure-categories",
+    "/api/failure-signatures",
+    "/api/notifications",
+    "/api/self-repair",
+    "/api/audit-events",
+    "/api/docs",
+    "/api/repos",
+    "/api/sync-root",
+    "/api/workers",
+    "/api/tasks",
+    "/api/reminders",
+];
+/**
+ * DX-4261: non-board-scoped routes a prefix cannot express, because their family root (`/api/issues`, `/api/catalog`) is board-scoped.
+ * `/api/agents` stays stamped: `?board=` there selects the roster read (DX-4220).
+ */
+const NON_BOARD_SCOPED_PATH_PATTERNS = [
+    /^\/api\/issues\/[^/]+\/(dispatches|problems)$/,
+    /^\/api\/catalog\/[^/]+$/,
+    // The LIST read only: `/api/plan-sessions/me/plan` reads the stamped board to pin the operator dispatch (DX-2954).
+    /^\/api\/plan-sessions$/,
+];
+/** DX-3750 — does `routePath` (`<basePath><path>`, no query string) take a `?board=` at all? See `NON_BOARD_SCOPED_PATH_PREFIXES`'s own doc. */
+export function isBoardScopedRoute(routePath) {
+    return !(NON_BOARD_SCOPED_PATH_PREFIXES.some((prefix) => routePath === prefix || routePath.startsWith(`${prefix}/`)) ||
+        NON_BOARD_SCOPED_PATH_PATTERNS.some((pattern) => pattern.test(routePath)));
+}
 export class DashboardHttpClient {
     config;
     fetchImpl;
@@ -11,7 +71,7 @@ export class DashboardHttpClient {
         this.fetchImpl = fetchImpl;
     }
     async request(args) {
-        const url = this.buildUrl(args.method, args.path, args.query, args.board, args.basePath);
+        const url = this.buildUrl(args.path, args.query, args.board, args.basePath);
         const headers = {
             Authorization: `Bearer ${this.config.token}`,
             Accept: "application/json",
@@ -87,7 +147,7 @@ export class DashboardHttpClient {
         }
         return { ok: false, status: res.status, body: parsed };
     }
-    buildUrl(method, path, extraQuery, boardOverride, basePath = "/api/issues") {
+    buildUrl(path, extraQuery, boardOverride, basePath = "/api/issues") {
         const base = this.config.baseUrl.replace(/\/+$/, "");
         const [rawPath, existingQs] = path.split("?", 2);
         let cleanPath;
@@ -98,8 +158,10 @@ export class DashboardHttpClient {
             cleanPath = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
         }
         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`.
-        if (isBoardScopedRoute(method, `${basePath}${cleanPath}`)) {
+        // DX-3750 — only a board-scoped route takes `?board=` at all; see
+        // `isBoardScopedRoute`'s own doc for why an unconditional stamp 400s
+        // plans/dispatches/boards-list through `danxbot_api`.
+        if (isBoardScopedRoute(`${basePath}${cleanPath}`)) {
             params.set("board", boardOverride ?? this.config.board);
         }
         if (extraQuery) {

package/dist/index.js

@@ -79,7 +79,7 @@ import { ACTIVITY_SUBCOMMAND, runActivityCommand } from "./activity.js";
 import { EVENT_TEXT_SUBCOMMAND, runEventTextCommand } from "./event-text.js";
 import { RESTART_NOTICE_SUBCOMMAND, runRestartNoticeCommand } from "./restart-notice.js";
 import { resolveDeclaredCredential } from "./credential.js";
-import { projectKeyOf, recordSessionConnectionAfterConnect } from "./session-connection.js";
+import { projectKeyOf, recordSessionConnectionAfterConnect, removeSessionConnectionAfterLeave } from "./session-connection.js";
 import { createListenerReminder, isPlanConnectedOnThisMachine, } from "./listener-reminder.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -462,13 +462,14 @@ strictTool("attach_file", "Attach a LOCAL file to a card: `card_id` + `path` (an
 // no existing plan for an id to name yet.
 strictTool("plan_connect", 
 // DX-2735: trimmed with the problem tools to stay inside the work-profile budget.
-"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth, missedEvents}` — `missedEvents` is `{events, omitted}`: the operator events on this plan that no session had been told about before you connected, oldest first, capped to the newest few (`omitted` counts the older ones left out) — read them before anything else. `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the plan read + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated plan-write tool) acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape the plan list/get routes report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. An action the operator DECLINES arrives as `... rejected the action \"<title>\" for \"<statement>\" — reason: \"<note>\". Do not perform it; re-plan from the reason` (a decision with `outcome: \"rejected\"` — never treat it as work done). Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself. The response's `reminders[]` (when present) carries the mantra — read and follow it.", {
+"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth, missedEvents}` — `missedEvents` is `{events, omitted}`: the operator events on this plan that no session had been told about before you connected, oldest first, capped to the newest few (`omitted` counts the older ones left out) — read them before anything else. `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the plan read + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated plan-write tool) acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape the plan list/get routes report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. An action the operator DECLINES arrives as `... rejected the action \"<title>\" for \"<statement>\" — reason: \"<note>\". Do not perform it; re-plan from the reason` (a decision with `outcome: \"rejected\"` — never treat it as work done). Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself. The response's `reminders[]` (when present) carries the mantra — read and follow it. To LEAVE: `{plan_id: <current plan>, disconnect: true}` returns `{session, leftPlan}`; a wrong plan is a 409.", {
     plan_id: z.number().int().positive().describe("The plan id, from the plans list (`danxbot_api` `GET /api/plans`)."),
     title: z
         .string()
         .min(1)
         .optional()
         .describe("THIS session's own Claude session title — from `get_session({session_id:\"self\"}).title`, passed verbatim, never invented or derived from the repo/cwd. Stored on your session's row: a title different from what is already stored UPDATES it; omit to leave the stored title untouched. Not this plan's name. At most 200 characters — an overlong title is refused with a 400 naming its length."),
+    disconnect: z.boolean().optional().describe("true = leave `plan_id` (your current plan); no `title`."),
 }, 
 // DX-2862 — the connect is also the moment this session's event bridge learns
 // WHICH dashboard credential owns its stream: of the dashboard MCP servers a
@@ -478,6 +479,11 @@ async (args) => {
     const result = await planConnect(client, args);
     // DX-3997 — a (re)connect restarts the bridge; the next `danxbot_api` must re-read health.
     listenerReminder.invalidate();
+    // DX-2985 — a leave drops the local connection record (the bridge exits on `not_connected`; a later connect writes a fresh one).
+    if (args.disconnect === true) {
+        removeSessionConnectionAfterLeave(result, config.session?.id);
+        return jsonResult(result);
+    }
     return jsonResult({
         ...result,
         ...recordSessionConnectionAfterConnect(result, {

package/dist/session-connection.js

@@ -170,6 +170,16 @@ export function recordSessionConnectionAfterConnect(result, inputs, write = writ
         };
     }
 }
+/**
+ * DX-2985 — drop this session's local connection record after a successful leave (`plan_connect {disconnect: true}`), so
+ * nothing on this machine still treats the session as plan-connected (the listener-reminder reads this record). A refused
+ * leave keeps it: the session is still on its plan. Never throws for an absent record.
+ */
+export function removeSessionConnectionAfterLeave(result, sessionId, home = homedir()) {
+    if (!result.ok || sessionId === undefined || sessionId === "")
+        return;
+    rmSync(sessionConnectionPath(sessionId, home), { force: true });
+}
 /** Why a parsed record cannot be used, or `null` when it can. */
 export function invalidRecordReason(value) {
     if (typeof value !== "object" || value === null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.214",
+  "version": "0.1.215",
   "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, danxbot_complete, and other per-dispatch lifecycle callbacks) (DX-3465, PLN-11 R-25).",
   "license": "MIT",
   "type": "module",

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

@@ -1,49 +0,0 @@
-/**
- * GENERATED by src/dashboard/mcp-board-scope.ts (DX-4303) - do not edit by hand.
- * Regenerate: DANX_REGEN_MCP_BOARD_SCOPE=1 npx vitest run src/dashboard/mcp-board-scope.test.ts
- *
- * The GET /api/* route templates the client must know to stamp `?board=` correctly, and whether each takes it. The server refuses an
- * unknown key on a list read whose vocabulary omits `board` and on a route declaring `strictQuery`; a path no template names is stamped.
- */
-export const GET_ROUTE_BOARD_SCOPE = [
-    ["/api/account/sessions", false],
-    ["/api/audit-events", false],
-    ["/api/boards", false],
-    ["/api/boards/:boardId", false],
-    ["/api/catalog/:catalogId", false],
-    ["/api/dispatches", false],
-    ["/api/dispatches/:dispatchId", true],
-    ["/api/dispatches/:dispatchId/logs", false],
-    ["/api/dispatches/:dispatchId/usage-events", false],
-    ["/api/dispatches/dead-letter-ids", false],
-    ["/api/docs/:repo/changes", false],
-    ["/api/failure-categories", false],
-    ["/api/failure-categories/ambiguous", false],
-    ["/api/failure-categories/uncategorized", false],
-    ["/api/failure-signatures", false],
-    ["/api/issues/:id/problems", false],
-    ["/api/issues/:id/usage-runs", false],
-    ["/api/issues/:id/usage-series", false],
-    ["/api/issues/:issueId/dispatches", false],
-    ["/api/notifications", false],
-    ["/api/plan-sessions", false],
-    ["/api/plans", false],
-    ["/api/plans/:planId/architecture/sections", false],
-    ["/api/plans/:planId/cards", false],
-    ["/api/plans/:planId/notes", false],
-    ["/api/plans/:planId/records", false],
-    ["/api/plans/:planId/usage-series", false],
-    ["/api/plans/mine/architecture/sections", false],
-    ["/api/platform/signup-codes", false],
-    ["/api/platform/teams", false],
-    ["/api/reminders", false],
-    ["/api/repos", false],
-    ["/api/self-repair/errors", false],
-    ["/api/sync-root", false],
-    ["/api/tasks", false],
-    ["/api/team/invitations", false],
-    ["/api/team/members", false],
-    ["/api/team/roles", false],
-    ["/api/users", false],
-    ["/api/workers", false],
-];

package/dist/route-board-scope.js

@@ -1,51 +0,0 @@
-/**
- * DX-4303 - does the dashboard route a request reaches take a `?board=` query key?
- *
- * The answer comes from the dashboard's own route table, shipped in this package as `route-board-scope.generated.ts` (generated by
- * the server's `src/dashboard/mcp-board-scope.ts`; a root test fails when it drifts). This file only matches a concrete request
- * path against those templates, the way the server's `RouteTable` does: segments compared left to right, a literal beating a
- * `:param` beating a trailing `*`. It holds no route knowledge of its own.
- *
- * 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";
-const RANK = { literal: 2, param: 1, rest: 0 };
-function compile(template, acceptsBoard) {
-    const segments = template
-        .slice(1)
-        .split("/")
-        .map((s) => (s === "*" ? { kind: "rest" } : s.startsWith(":") ? { kind: "param" } : { kind: "literal", value: s }));
-    return { segments, rank: segments.map((s) => RANK[s.kind]), acceptsBoard };
-}
-function compareRank(a, b) {
-    const n = Math.max(a.length, b.length);
-    for (let i = 0; i < n; i++) {
-        const x = a[i] ?? -1;
-        const y = b[i] ?? -1;
-        if (x !== y)
-            return y - x;
-    }
-    return 0;
-}
-const ROUTES = GET_ROUTE_BOARD_SCOPE.map(([template, accepts]) => compile(template, accepts)).sort((a, b) => compareRank(a.rank, b.rank));
-function matches(route, parts) {
-    for (let i = 0; i < route.segments.length; i++) {
-        const seg = route.segments[i];
-        if (seg.kind === "rest")
-            return true;
-        const part = parts[i];
-        if (part === undefined)
-            return false;
-        if (seg.kind === "literal" ? part !== seg.value : part === "")
-            return false;
-    }
-    return parts.length === route.segments.length;
-}
-/** Does the dashboard route `<method> <routePath>` (no query string) take a `?board=` query key? */
-export function isBoardScopedRoute(method, routePath) {
-    if (method !== "GET")
-        return true;
-    const parts = routePath.slice(1).split("/");
-    return ROUTES.find((route) => matches(route, parts))?.acceptsBoard ?? true;
-}