@thehammer/danx-dashboard-mcp 0.1.233 → 0.1.236

package/README.md

@@ -10,6 +10,7 @@ Stdio MCP server fronting danxbot's dashboard HTTP API. Since DX-3465 it exposes
 |---|---|
 | `DANXBOT_DASHBOARD_URL` | Dashboard base, e.g. `http://danxbot-dashboard:5555` (inside compose) or `http://localhost:5555` (host) |
 | `DANX_DASHBOARD_CREDENTIAL` | A DISPATCH's credential: the bearer verbatim, substituted into the materialized `.mcp.json` from its overlay (DX-2862, `src/credential.ts`). Authoritative when set; it never signs out. An operator session sets nothing: with no credential the server boots SIGNED OUT, every tool except `plan_connect` returns one "not signed in" halt, and `plan_connect` requests access (below). The same resolver serves the `bridge` subcommand, so a session's tools and its event stream can never sign in as two different identities |
+| `DANXBOT_TEAM` | OPTIONAL, non-secret (DX-4446): the team slug (or id) whose approvers see this session's access request in their danxbot site. Set it in the repo's `.mcp.json` env block or the shell. Unset, the request is answered by link only. A value that is not a team slug fails at boot; a team the dashboard does not know makes `plan_connect` answer `unknown_team` (fix `DANXBOT_TEAM`), never a silent link fallback |
 | `DANX_REPO_NAME` | Repo half of the qualified board id |
 | `DANXBOT_BOARD_NAME` | Board-slug half of the qualified board id (the dispatch injects `board.slug` here) |
 
@@ -38,6 +39,7 @@ All exposed as `mcp__danx-dashboard__<name>` once wired through the workspace `m
 | `danxbot_api` | `{method, path, query?, body?}` — calls any dashboard route the caller's credential may reach (card/plan CRUD, comments, dependencies, problems/solutions, quality gates, retro, triage, transitions, …). Returns `{ok, status, body}`; `body` carries the route's own response, or its structured error verbatim when `ok:false`. While this session is plan-connected, the dashboard's own reminders for it (today: `plan_list.listener_unattached`, attached by the server to `GET /api/plans` when the event listener is unattached past the startup grace, DX-3997) are relayed into the body's `reminders[]`; the MCP carries no reminder text or state of its own and re-reads at most every 30s. |
 | `danxbot_api_list` | No args. Lists the routes this caller's credential may reach as `{routes: ["METHOD /path"], external: [{route, served_by}]}` (one bare string per route, exactly what `danxbot_api_spec` takes) — call this first when you don't know the route for what you need to do. |
 | `danxbot_api_spec` | `{endpoints}` (comma-joined `METHOD /path` list, required, min 1). Returns the exact OpenAPI contract for those routes — call this when you know the route but not its exact request/response shape. |
+| `attach_file` | `{card_id, path, replaces?, primary?, filename?, content_type?}` — the server reads the LOCAL file at `path` (absolute, `/tmp/a.png` or `C:\x\a.png`) and uploads it, so its bytes never pass through the agent's context. `replaces: <attachment id>` swaps that attachment's file in place (`PUT /api/issues/:id/attachments/:aid`: same id, name and cover flag) instead of adding one; `primary: true` makes it the card's single cover, atomically with the write. Reply: `{issue: <compact row>, attachment_id, url, thumbnail_url, is_primary}`. Opt-in: granted to `slack-agent` and `work` (DX-4386) through `extraTools`. A screenshot of browser-visible work: first `primary: true`, then `replaces` at each milestone. |
 | `request_permission` | `{permissions, reason}` — asks a person to grant this key ONE MORE permission (see "Asking for one more permission" above). Answers at once with the approval URL and confirm code; the grant is picked up in the background. |
 
 There is no dedicated `resource_fields` tool (removed DX-3465 — it was a thin wrapper `danxbot_api` already reaches with no agent-specific behavior earning it its own tool). What an opt-in field TREE may name for one resource (`{resource, description, always, hashes, fields, relations}`) is `danxbot_api({method:"GET", path:"/api/resources/<resource>/fields"})` — install-global, no `board`; `resource: "issue"` is the root, and a relation's own `resource` in the response is what to call this again with, one level deeper.

package/dist/access-request.js

@@ -1,4 +1,14 @@
 import { assertVersionFloorSatisfied, MCP_MIN_VERSION_HEADER } from "./version-floor.js";
+// DX-4446: mirrors TEAM_SLUG_PATTERN in src/lib/auth-rules.ts (this package cannot import the main src/); a team ref is a slug,
+// and a team id's digits are a slug too. Keep the two in step.
+const TEAM_REF_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/** DX-4446: the `DANXBOT_TEAM` value, or a loud error naming the variable. */
+export function assertMcpTeamRef(value) {
+    if (!TEAM_REF_PATTERN.test(value)) {
+        throw new Error(`[danx-dashboard-mcp] DANXBOT_TEAM "${value}" is not a team slug or id: lowercase letters and digits, joined by single hyphens`);
+    }
+    return value;
+}
 function baseOf(dashboardUrl) {
     return dashboardUrl.replace(/\/+$/, "");
 }
@@ -51,6 +61,9 @@ function isCreated(value) {
 export async function createAccessRequest(fetchImpl, dashboardUrl, input) {
     const url = `${baseOf(dashboardUrl)}/api/access-requests`;
     const { status, headers, json } = await postPublic(fetchImpl, url, input);
+    if (status === 400 && input.team !== undefined && json?.error === "unknown_team") {
+        return { kind: "unknown_team", team: input.team };
+    }
     if (status === 201) {
         if (!isCreated(json)) {
             throw new Error(`[danx-dashboard-mcp] POST ${url} answered 201 without the access request fields: ${JSON.stringify(json)}`);

package/dist/handlers.js

@@ -212,8 +212,9 @@ export function inferAttachmentMime(filename) {
  * Attach a local file to a card. Reads the bytes from the dispatch's
  * shared filesystem (this MCP server runs co-located with the agent that
  * calls it), then forwards to the dashboard's `POST /api/issues/:id/attachments`
- * route — the SAME ingest the dashboard UI's own upload uses: stores the
- * bytes in S3, inserts one attachment row, and (via the dashboard's
+ * route (or, with `replaces`, `PUT /api/issues/:id/attachments/:aid`, which swaps that row's bytes in place) — the
+ * SAME ingest the dashboard UI's own upload uses: stores the
+ * bytes in S3, inserts or updates one attachment row, and (via the dashboard's
  * existing outbound projection) auto-mirrors the file to the card's
  * linked Trello card and Slack thread. Board-scoped; see `board`.
  *
@@ -234,21 +235,33 @@ export async function attachFile(client, args, deps = {}) {
     if (!isAbsolute(args.path)) {
         throw new Error(`attach_file: path must be an absolute path (got "${args.path}")`);
     }
+    // DX-4386: the replaced row keeps its stored name, so a filename override has nothing to apply to - refuse it loudly, before any read.
+    if (args.replaces !== undefined && args.filename !== undefined) {
+        throw new Error("attach_file: filename cannot be set with replaces (the replaced attachment keeps its name)");
+    }
     const read = deps.readFile ?? readFile;
     // A missing / unreadable file rejects here — no HTTP call is made, so no
     // S3 upload, no row insert, and no projection are ever triggered.
     const bytes = await read(args.path);
+    const contentTypeOf = (name) => (args.content_type?.trim() ? args.content_type.trim() : inferAttachmentMime(name));
+    const issuePath = `/${encodeURIComponent(args.card_id)}/attachments`;
+    // DX-4386: `primary` is the dashboard's own atomic option (one live cover, set in the write's own transaction); an absent flag sends no key.
+    const primary = args.primary === undefined ? {} : { primary: args.primary };
+    if (args.replaces !== undefined) {
+        return client.request({
+            method: "PUT",
+            basePath: "/api/issues",
+            path: `${issuePath}/${args.replaces}`,
+            body: { contentType: contentTypeOf(basename(args.path)), base64: bytes.toString("base64"), ...primary },
+            board: args.board,
+        });
+    }
     const filename = args.filename?.trim() ? args.filename.trim() : basename(args.path);
-    const contentType = args.content_type?.trim() ? args.content_type.trim() : inferAttachmentMime(filename);
     return client.request({
         method: "POST",
         basePath: "/api/issues",
-        path: `/${encodeURIComponent(args.card_id)}/attachments`,
-        body: {
-            filename,
-            contentType,
-            base64: bytes.toString("base64"),
-        },
+        path: issuePath,
+        body: { filename, contentType: contentTypeOf(filename), base64: bytes.toString("base64"), ...primary },
         board: args.board,
     });
 }

package/dist/index.js

@@ -61,6 +61,12 @@
  *     otherwise this session's approved key (`session-key.ts`), else none: the
  *                           server boots SIGNED OUT, every tool but `plan_connect`
  *                           halts, and `plan_connect` requests access (`session-access.ts`)
+ *   DANXBOT_TEAM            OPTIONAL (DX-4446), non-secret: the team slug (or id) whose
+ *                           approvers see this session's access request in their danxbot
+ *                           site. Set it in the repo's `.mcp.json` env block or the shell.
+ *                           Unset: the request is answered by link only. Set but not a
+ *                           valid ref, or unknown to the dashboard: fails loud, never a
+ *                           silent fall back to the link flow.
  *   DANX_REPO_NAME          repo half of the qualified board id
  *   DANXBOT_BOARD_NAME      board-slug half of the qualified board id
  *                           (the dispatch injects `board.slug` here);
@@ -83,6 +89,7 @@ import { EVENT_TEXT_SUBCOMMAND, runEventTextCommand } from "./event-text.js";
 import { RESTART_NOTICE_SUBCOMMAND, runRestartNoticeCommand } from "./restart-notice.js";
 import { resolveBootCredential } from "./credential.js";
 import { SessionKeyUnusableError, deleteSessionKey } from "./session-key.js";
+import { assertMcpTeamRef } from "./access-request.js";
 import { SessionAccess } from "./session-access.js";
 import { PermissionRequests } from "./permission-request.js";
 import { withForbiddenHint } from "./forbidden-hint.js";
@@ -119,6 +126,19 @@ function readEnvOptional(name) {
     const v = process.env[name];
     return typeof v === "string" && v !== "" ? v : undefined;
 }
+/** DX-4446: optional `DANXBOT_TEAM`; set, it must be a valid team ref or boot fails loud (no fallback to the link flow). */
+function readTeamRef() {
+    const team = readEnvOptional("DANXBOT_TEAM");
+    if (team === undefined)
+        return undefined;
+    try {
+        return assertMcpTeamRef(team);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+}
 // The dispatch config + HTTP client are LATE-BOUND (assigned by `boot()` at
 // entrypoint, below). Tool registration happens at module import and the
 // callbacks close over these `let` bindings, reading them at CALL time — so the
@@ -168,6 +188,7 @@ function boot() {
         sessionId: session?.id,
         repo,
         clientVersion: readOwnVersion(),
+        team: readTeamRef(),
         setToken: (token) => dashboardClient.setToken(token),
         initial: resolveInitialCredential(dashboardUrl, session?.id),
         log: (line) => console.error(line),
@@ -475,14 +496,18 @@ strictTool("attach_file", "Attach a LOCAL file to a card. This server reads and
     "context. The attachment mirrors to the card's linked Trello card and Slack thread. 25 MB limit (413). " +
     "Returns `{issue, attachment_id, url, thumbnail_url, is_primary}`: `url` is permanent, embed it in any " +
     "markdown field as `![description](url)` and it renders inline. Use it when a screenshot or file judges something faster than prose, or instead of pasting a " +
-    "large CSV or log into a card field.", {
+    "large CSV or log into a card field. A screenshot: first with `primary: true`, then `replaces: <id>` each milestone.", {
     card_id: z.string().min(1).describe("The card id to attach the file to."),
-    path: z
-        .string()
-        .min(1)
-        .describe("Absolute path to a local file on the dispatch's shared filesystem (must start with `/`)."),
+    path: z.string().min(1).describe("Absolute local path on the machine this server runs on (`/tmp/a.png` or `C:\\x\\a.png`)."),
     filename: z.string().min(1).optional().describe("Override for the stored filename; default: path's basename."),
     content_type: z.string().min(1).optional().describe("Override for the stored MIME type; default: an extension guess."),
+    replaces: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Id of this card's attachment to replace in place: it keeps its id, name and cover flag. Not with `filename`."),
+    primary: z.boolean().optional().describe("Make this attachment the card's single cover (lead image)."),
     ...boardField,
 }, async (args) => guardedJson(() => attachFile(client, args)));
 // ---------------- request_permission (DX-4434, parent DX-4432) ----------------

package/dist/session-access.js

@@ -47,6 +47,7 @@ const DENIED_INSTRUCTION = "The user denied the request. Do not retry unless the
 const DASHBOARD_OUTDATED_ERROR = "this dashboard does not support request-and-approve yet (POST /api/access-requests answered 404): " +
     "it must be updated before this session can sign in";
 const RATE_LIMITED_ERROR = "too many access requests from this address; wait, then call plan_connect again";
+const unknownTeamError = (team) => `the dashboard has no team "${team}" (DANXBOT_TEAM); fix DANXBOT_TEAM in this server's env (the repo's .mcp.json env block or the shell) and restart the session`;
 const NO_SESSION_ID_ERROR = "this server has no CLAUDE_CODE_SESSION_ID, so it cannot request a session key";
 const CLAIMED_LOST_ERROR = "the dashboard says this request was already claimed, but this process never received the key; " +
     "start a new request";
@@ -212,10 +213,13 @@ export class SessionAccess {
             repo: this.deps.repo,
             machine: this.deps.machine ?? hostname(),
             clientVersion: this.deps.clientVersion,
+            ...(this.deps.team === undefined ? {} : { team: this.deps.team }),
         });
         switch (created.kind) {
             case "dashboard_outdated":
                 return notReady({ state: "dashboard_outdated", error: DASHBOARD_OUTDATED_ERROR }, true);
+            case "unknown_team":
+                return notReady({ state: "unknown_team", team: created.team, error: unknownTeamError(created.team) }, true);
             case "rate_limited":
                 return notReady({ state: "rate_limited", retryAfterSeconds: created.retryAfterSeconds, error: RATE_LIMITED_ERROR }, true);
             case "refused":

package/package.json

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