dokutrak-mcp 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+All notable changes to `dokutrak-mcp` are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
+[SemVer](https://semver.org/). The tool surface (names, descriptions, inputs)
+is part of the public contract: it changes only with a decision recorded in
+the DokuTrak product repository, and every such change is listed here.
+
+## [0.1.0] — 2026-09-14
+
+First public release. One complete round trip — ask, chase, know, collect —
+as decided in ADR-014 of the DokuTrak product repository.
+
+### Added
+
+- `create_request` — creates a Document Request and sends it, in one call.
+  Two API calls under the hood, creation with `sendEmail: false` then send,
+  so a failed email is reported with the id of the request it left behind.
+- `request_replacement` — the deterministic chase on rejected files. Nothing
+  is emailed by the call itself; the request returns to the reminder cadence.
+- `get_request` — status, checklist, every collected file with its verdict,
+  and the reminder state, in one call. By id, or by a search term.
+- `download_documents` — every collected file as one zip, embedded in the
+  result as binary content (no link, no disk write).
+- stdio transport; authentication by an Agent Connection read from
+  `DOKUTRAK_API_KEY`, never from the command line; `DOKUTRAK_API_URL` to
+  point at another deployment.
+- Contract tests at the MCP seam: a real client and the real server over the
+  SDK's in-memory transport, HTTP stubbed at `fetch`, no account needed.
+- `npm run staging` — the scripted run against a real workspace
+  (create → chase → read → collect → revoke → 401), never a CI check.
+
+### Not in this release
+
+- claude.ai (remote MCP over HTTP with OAuth). Only Claude Desktop and Claude
+  Code, or any client that launches a stdio server with an `env` block.
+- Approving or rejecting a document, billing, workspace settings, key
+  management: the service refuses them to every Agent Connection, whatever
+  the connector.
+
+[0.1.0]: https://github.com/Crackx17/dokutrak-mcp/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arthur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# dokutrak-mcp
+
+The open [MCP](https://modelcontextprotocol.io) connector for [DokuTrak](https://dokutrak.com):
+let your agent chase the documents.
+
+DokuTrak collects documents from your clients on your behalf: you send a request, the client
+uploads through a secure link, the files are reviewed, and silent clients get reminded. This
+connector puts that loop inside the agent you already work in, so "where does the Dupont file
+stand?" is answered without leaving Claude.
+
+The connector is a thin, stateless client of the DokuTrak API. It holds the Agent Connection
+you give it, stores nothing on disk, keeps no cache, and duplicates no rule: what your agent may
+and may not do is decided by the service, and refusals come back as tool errors with the
+service's own explanation.
+
+## Install
+
+You need a DokuTrak workspace and an **Agent Connection**, issued from
+**Settings → Connect an agent** in the DokuTrak app. That screen hands you a paste-ready
+configuration with your key already in place; the instructions below are the same thing, by hand.
+
+The key is read from the environment variable `DOKUTRAK_API_KEY`. It is never taken from the
+command line.
+
+### Claude Desktop
+
+Open the configuration file:
+
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+Add the server under `mcpServers` (create the object if the file is empty):
+
+```json
+{
+  "mcpServers": {
+    "dokutrak": {
+      "command": "npx",
+      "args": ["-y", "dokutrak-mcp"],
+      "env": { "DOKUTRAK_API_KEY": "dk_live_…" }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. The DokuTrak tools appear in the tools menu of a new conversation.
+
+### Claude Code
+
+```bash
+claude mcp add dokutrak -e DOKUTRAK_API_KEY=dk_live_… -- npx -y dokutrak-mcp
+```
+
+Then `/mcp` inside Claude Code lists `dokutrak` and its tools.
+
+### claude.ai
+
+**Not supported in this release.** claude.ai connects to remote MCP servers over HTTP with
+OAuth; this connector speaks stdio with an API key, which is what a local install into Claude
+Desktop or Claude Code needs. A hosted variant is a separate, later decision.
+
+### From a clone, before the npm release
+
+```bash
+git clone https://github.com/Crackx17/dokutrak-mcp.git
+cd dokutrak-mcp
+npm ci && npm run build
+```
+
+Then point the client at the built file instead of `npx`:
+
+```json
+{
+  "mcpServers": {
+    "dokutrak": {
+      "command": "node",
+      "args": ["/path/to/dokutrak-mcp/dist/cli.js"],
+      "env": { "DOKUTRAK_API_KEY": "dk_live_…" }
+    }
+  }
+}
+```
+
+or, for Claude Code: `claude mcp add dokutrak -e DOKUTRAK_API_KEY=dk_live_… -- node /path/to/dokutrak-mcp/dist/cli.js`.
+
+## Configuration
+
+| Variable           | Required | Default                          | Meaning                                                    |
+| ------------------ | -------- | -------------------------------- | ---------------------------------------------------------- |
+| `DOKUTRAK_API_KEY` | yes      | —                                | The Agent Connection, from Settings → Connect an agent.    |
+| `DOKUTRAK_API_URL` | no       | `https://app.dokutrak.com/api`   | Base URL of the API. Ends in `/api`; the connector adds `/v1`. |
+
+## Tools
+
+Four tools, one round trip: ask, chase, know, collect.
+
+### `create_request`
+
+Creates a Document Request **and** sends it, in one call, so nothing is left created but unsent.
+Takes the client's email, a deadline (`YYYY-MM-DD` or an ISO datetime), the checklist of
+documents wanted, and an optional title and message. The email goes to the recipient given here
+and to nobody else; the client uploads through the secure link it contains. Under the hood this
+is the same two-step the DokuTrak app performs: create with `sendEmail: false`, then send. If the
+send fails, the error names the created request, which stays visible in the dashboard.
+
+### `request_replacement`
+
+Chases the client on the rejected files of a request: flags them, moves the request back to
+awaiting the client, and returns it to the automatic reminder cadence. **This call sends no
+email by itself**; the reminders do. The optional message is recorded in the request's audit
+trail and is not sent to the client. It refuses a request with no rejected file.
+
+### `get_request`
+
+Where a Document Request stands, in one call: status, the checklist, every collected file with
+its verdict (approved, rejected with the reviewer's reason, or pending), and the reminder state.
+Give a `request_id`, or a `search` term matching the title or the client's name or email. When
+several requests match, the tool returns the candidates and asks for the id.
+
+### `download_documents`
+
+Every collected file of a request, as one zip archive. The archive comes back **embedded in the
+tool result as binary content** (an MCP resource with a base64 blob and `application/zip`), not
+as a link: the API has no short-link endpoint for a zip, and the connector writes nothing to
+disk. What the agent does with the bytes is decided on the professional's side, exactly like a
+download from the browser. Large archives make large results; check with `get_request` that
+documents have arrived before calling it.
+
+## What the connector cannot do
+
+Approving or rejecting a document is your decision, taken in the DokuTrak dashboard. No tool
+here can take it, and the service refuses it to any Agent Connection regardless of which
+connector asks. The same goes for billing, workspace settings and the management of API keys.
+
+Revoking the Agent Connection in DokuTrak takes effect on the very next call: the connector
+answers with the service's 401 and nothing else.
+
+## Development
+
+```bash
+npm ci
+npm run check   # typecheck, build, tests
+npm test        # tests alone
+```
+
+The tests are contract tests at the MCP seam: a real MCP client and the real server, connected
+in memory through the official SDK's transport, with HTTP stubbed at `fetch` using recorded
+responses. They call tools, never functions, and run with no DokuTrak account and no network.
+
+### The staging run
+
+Before a release, the built binary is driven once against a real workspace, by a real MCP
+client over stdio: create → chase → read → collect → revoke → 401. It is a record pasted into
+the release PR, never a CI check (a blocking check calls no third party). It pauses twice for
+acts the service refuses to any Agent Connection: rejecting the uploaded file, and revoking
+the key.
+
+```bash
+npm run build
+DOKUTRAK_API_KEY=dk_live_… STAGING_RECIPIENT_EMAIL=you@example.com npm run staging
+```
+
+A real Document Request is created and a real email goes to `STAGING_RECIPIENT_EMAIL`. The
+transcript lands in `staging-run-<timestamp>.md` (git-ignored); the key is never written to it.
+
+### Releasing
+
+A tag `vX.Y.Z` matching `package.json` and `SERVER_VERSION` triggers `.github/workflows/release.yml`:
+`npm run check`, `npm publish` (trusted publishing through GitHub's OIDC token, provenance
+attached), then the listing in the [MCP Registry](https://registry.modelcontextprotocol.io) as
+`io.github.Crackx17/dokutrak-mcp` — the `mcpName` of `package.json`, which the registry checks
+against the published tarball. Running the workflow by hand does a `--dry-run` and publishes nothing.
+
+## License
+
+[MIT](LICENSE).

package/dist/cli.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+var CONNECTION_ENV_VAR = "DOKUTRAK_API_KEY";
+var API_URL_ENV_VAR = "DOKUTRAK_API_URL";
+var DEFAULT_API_URL = "https://app.dokutrak.com/api";
+var ConfigError = class extends Error {
+};
+function readConfig(env = process.env) {
+  const apiKey = env[CONNECTION_ENV_VAR]?.trim();
+  if (!apiKey) {
+    throw new ConfigError(
+      `${CONNECTION_ENV_VAR} is not set. Create an Agent Connection in DokuTrak (Settings \u2192 Connect an agent) and put the key in the "env" block of your MCP client configuration.`
+    );
+  }
+  const baseUrl = (env[API_URL_ENV_VAR]?.trim() || DEFAULT_API_URL).replace(
+    /\/+$/,
+    ""
+  );
+  return { apiKey, baseUrl };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/api.ts
+var ApiError = class extends Error {
+  status;
+  title;
+  detail;
+  problem;
+  constructor(status, title, detail, problem) {
+    super(`${title} (${status}): ${detail}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.title = title;
+    this.detail = detail;
+    this.problem = problem;
+  }
+};
+function createApiClient(options) {
+  const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const headers = {
+    Authorization: `Bearer ${options.apiKey}`,
+    "User-Agent": options.userAgent ?? "dokutrak-mcp"
+  };
+  function url(path, query) {
+    const u = new URL(baseUrl + path);
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0) u.searchParams.set(key, value);
+    }
+    return u.toString();
+  }
+  async function raiseIfNotOk(res) {
+    if (res.ok) return;
+    const text = await res.text();
+    let problem;
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed && typeof parsed === "object") problem = parsed;
+    } catch {
+    }
+    const title = problem?.title ?? res.statusText ?? "Request failed";
+    const detail = problem?.detail ?? (text.trim() || `The API answered ${res.status} with no detail.`);
+    throw new ApiError(res.status, title, detail, problem);
+  }
+  async function json(path, init, query) {
+    const res = await fetchImpl(url(path, query), {
+      ...init,
+      headers: { ...headers, Accept: "application/json", ...init.headers }
+    });
+    await raiseIfNotOk(res);
+    return await res.json();
+  }
+  return {
+    get: (path, query) => json(path, { method: "GET" }, query),
+    post: (path, body) => json(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body ?? {})
+    }),
+    async getBinary(path) {
+      const res = await fetchImpl(url(path), { method: "GET", headers });
+      await raiseIfNotOk(res);
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      return {
+        bytes,
+        contentType: res.headers.get("content-type") ?? "application/octet-stream",
+        fileName: fileNameFromDisposition(res.headers.get("content-disposition"))
+      };
+    }
+  };
+}
+function fileNameFromDisposition(header) {
+  if (!header) return void 0;
+  const utf8 = /filename\*=UTF-8''([^;]+)/i.exec(header);
+  if (utf8?.[1]) return decodeURIComponent(utf8[1]);
+  const plain = /filename="?([^";]+)"?/i.exec(header);
+  return plain?.[1];
+}
+
+// src/tools/create-request.ts
+import { z } from "zod";
+
+// src/result.ts
+async function runTool(body) {
+  try {
+    return await body();
+  } catch (error) {
+    return errorResult(describe(error));
+  }
+}
+function describe(error) {
+  if (error instanceof ApiError) {
+    const code = typeof error.problem?.code === "string" ? ` [${error.problem.code}]` : "";
+    return `DokuTrak refused the call \u2014 ${error.title} (${error.status})${code}: ${error.detail}`;
+  }
+  if (error instanceof Error) {
+    return `The Connector could not reach DokuTrak: ${error.message}`;
+  }
+  return `The Connector failed: ${String(error)}`;
+}
+function errorResult(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+function jsonResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+
+// src/tools/create-request.ts
+var CREATE_REQUEST_DESCRIPTION = "Call this when the Professional wants to ask a Client for documents: it creates the Document Request and sends the email in one step, so nothing is left created but unsent. Provide the Client email, a deadline, and the list of documents wanted, plus an optional title and a message written by the Professional. The email goes to the recipient given here and to nobody else, and the Client uploads through the secure link it contains. If the email fails after creation, the error names the created request so it can be sent from the dashboard.";
+var registerCreateRequest = (server, api) => {
+  server.registerTool(
+    "create_request",
+    {
+      title: "Create and send a Document Request",
+      description: CREATE_REQUEST_DESCRIPTION,
+      inputSchema: {
+        recipient_email: z.email().describe("The Client who must upload the documents. The only address the email will go to."),
+        recipient_name: z.string().min(1).max(255).optional().describe("How the Client is addressed in the email."),
+        title: z.string().min(1).max(500).optional().describe("Title of the request, as the Professional names the file."),
+        message: z.string().min(1).max(1e3).optional().describe("A message from the Professional to the Client, included in the email."),
+        deadline: z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.]+(Z|[+-]\d{2}:\d{2}))?$/, "A date (YYYY-MM-DD) or an ISO 8601 datetime.").describe("When the documents are due. A date (YYYY-MM-DD) or an ISO 8601 datetime."),
+        documents: z.array(
+          z.object({
+            title: z.string().min(1).max(500).describe("What is asked for, as the Client will read it."),
+            description: z.string().min(1).max(1e3).optional().describe("Precision for the Client, for example which period."),
+            required: z.boolean().optional().describe("Defaults to true."),
+            coverage_days: z.number().int().positive().optional().describe("For a span rather than a file: how many days the documents must cover.")
+          })
+        ).min(1).describe("The checklist the Client must fill.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+    },
+    (input) => runTool(async () => {
+      const created = await api.post("/v1/requests", {
+        recipientEmail: input.recipient_email,
+        ...input.recipient_name && { recipientName: input.recipient_name },
+        ...input.title && { title: input.title },
+        ...input.message && { message: input.message },
+        deadline: toDeadlineIso(input.deadline),
+        sendEmail: false,
+        documents: input.documents.map((doc) => ({
+          title: doc.title,
+          ...doc.description && { description: doc.description },
+          ...doc.required !== void 0 && { required: doc.required },
+          ...doc.coverage_days !== void 0 && { coverage_days: doc.coverage_days }
+        }))
+      });
+      const id = created.data.id;
+      try {
+        const sent = await api.post(`/v1/requests/${id}/send`, {});
+        return jsonResult({
+          requestId: id,
+          title: created.data.title,
+          status: created.data.status,
+          recipient: { name: created.data.recipientName, email: created.data.recipientEmail },
+          deadline: created.data.deadline,
+          sent: true,
+          uploadLinkExpiresAt: sent.data?.expiresAt ?? null
+        });
+      } catch (error) {
+        const reason = error instanceof ApiError ? `${error.title} (${error.status}): ${error.detail}` : describe(error);
+        return errorResult(
+          `Document Request ${id} was created but the email did not go out \u2014 ${reason}. It is visible in the DokuTrak dashboard, where it can be sent.`
+        );
+      }
+    })
+  );
+};
+function toDeadlineIso(deadline) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(deadline) ? `${deadline}T12:00:00.000Z` : deadline;
+}
+
+// src/tools/request-replacement.ts
+import { z as z2 } from "zod";
+var REQUEST_REPLACEMENT_DESCRIPTION = "Call this when a Document Request has rejected files and the Professional wants the Client to send them again. It flags every rejected file, moves the request back to awaiting the Client, and returns it to the automatic reminder cadence, which is what reaches the Client. Nothing is emailed by this call itself, and the optional message is kept in the audit trail rather than sent. Do not use it on a request with no rejected file; get_request shows which files were rejected.";
+var registerRequestReplacement = (server, api) => {
+  server.registerTool(
+    "request_replacement",
+    {
+      title: "Chase the Client on rejected files",
+      description: REQUEST_REPLACEMENT_DESCRIPTION,
+      inputSchema: {
+        request_id: z2.uuid().describe("The Document Request whose rejected files must be sent again."),
+        message: z2.string().min(1).max(1e3).optional().describe("A note from the Professional, recorded in the audit trail of the request. Not sent to the Client.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    ({ request_id, message }) => runTool(async () => {
+      await api.post(`/v1/requests/${request_id}/request-resubmission`, {
+        ...message && { message }
+      });
+      const after = await api.get(`/v1/requests/${request_id}`);
+      const r = after.data;
+      return jsonResult({
+        requestId: r.id,
+        status: r.status,
+        recipient: { name: r.recipientName, email: r.recipientEmail },
+        reminders: {
+          enabled: r.reminderEnabled ?? null,
+          sentCount: r.reminderCount ?? 0,
+          nextDueAt: r.nextReminderAt ?? null,
+          pausedUntil: r.reminderPausedUntil ?? null
+        },
+        note: "No email was sent by this call. The Client will be reached by the reminder cadence."
+      });
+    })
+  );
+};
+
+// src/tools/get-request.ts
+import { z as z3 } from "zod";
+var GET_REQUEST_DESCRIPTION = "Call this when the Professional asks where a Document Request stands: which documents arrived, which were approved or rejected, and when the Client was last chased. Give the request id when you have it, or a search term matching the title, the Client name or the Client email; several matches come back as a short list to choose from. One call returns the status, the checklist, every collected file with its verdict, and the reminder state, so no follow-up read is needed. Approving or rejecting a document is the decision of the Professional, made in the DokuTrak dashboard, and no tool here can take it.";
+var CANDIDATES_LIMIT = "10";
+var registerGetRequest = (server, api) => {
+  server.registerTool(
+    "get_request",
+    {
+      title: "Where does a Document Request stand",
+      description: GET_REQUEST_DESCRIPTION,
+      inputSchema: {
+        request_id: z3.uuid().optional().describe("The id of the Document Request, when known."),
+        search: z3.string().min(1).max(200).optional().describe(
+          "Text to match against the request title, the Client name or the Client email, when the id is not known."
+        )
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    ({ request_id, search }) => runTool(async () => {
+      if (request_id) return jsonResult(await compose(api, request_id));
+      if (!search) {
+        return errorResult(
+          "Give either request_id or search: without one of them there is nothing to look up."
+        );
+      }
+      const list = await api.get("/v1/requests", {
+        search,
+        limit: CANDIDATES_LIMIT
+      });
+      const rows = list.data ?? [];
+      if (rows.length === 0) {
+        return errorResult(`No Document Request matches "${search}".`);
+      }
+      if (rows.length === 1 && rows[0]) {
+        return jsonResult(await compose(api, rows[0].id));
+      }
+      return jsonResult({
+        matches: rows.map(summarize),
+        total: list.pagination?.total ?? rows.length,
+        hint: "Several Document Requests match. Call get_request again with the request_id of the right one."
+      });
+    })
+  );
+};
+async function compose(api, requestId) {
+  const [detail, documents] = await Promise.all([
+    api.get(`/v1/requests/${requestId}`),
+    api.get(`/v1/requests/${requestId}/documents`)
+  ]);
+  const r = detail.data;
+  return {
+    request: {
+      id: r.id,
+      title: r.title,
+      status: r.status,
+      recipient: { name: r.recipientName, email: r.recipientEmail },
+      message: r.message,
+      deadline: r.deadline,
+      createdAt: r.createdAt,
+      updatedAt: r.updatedAt,
+      completedAt: r.completedAt ?? null,
+      uploadLink: {
+        active: r.hasMagicLink ?? false,
+        lastOpenedByClientAt: r.linkOpenedAt ?? null
+      }
+    },
+    checklist: (r.documentRequirements ?? []).map((slot) => ({
+      title: slot.title ?? null,
+      docType: slot.doc_type ?? null,
+      description: slot.description ?? null,
+      required: slot.required !== false,
+      ...slot.coverage_days !== void 0 && { coverageDays: slot.coverage_days }
+    })),
+    documents: (documents.data ?? []).map((doc) => ({
+      id: doc.id,
+      name: doc.name,
+      type: doc.type,
+      size: doc.size,
+      verdict: doc.validationStatus,
+      rejectionReason: doc.rejectionReason
+    })),
+    reminders: {
+      enabled: r.reminderEnabled ?? null,
+      sentCount: r.reminderCount ?? 0,
+      lastSentAt: r.lastReminderAt ?? null,
+      nextDueAt: r.nextReminderAt ?? null,
+      pausedUntil: r.reminderPausedUntil ?? null,
+      pauseReason: r.reminderPauseReason ?? null
+    },
+    ...r.coverage !== void 0 && { coverage: r.coverage }
+  };
+}
+function summarize(row) {
+  return {
+    id: row.id,
+    title: row.title,
+    status: row.status,
+    recipient: { name: row.recipientName, email: row.recipientEmail },
+    deadline: row.deadline,
+    createdAt: row.createdAt,
+    documentsCollected: row.uploadedDocumentCount ?? null
+  };
+}
+
+// src/tools/download-documents.ts
+import { z as z4 } from "zod";
+var DOWNLOAD_DOCUMENTS_DESCRIPTION = "Call this when the Professional wants the files a Client has uploaded on a Document Request, for example to file them or read them locally. It returns every collected document as one zip archive, embedded in the result as binary content. The archive is the same download the dashboard offers and comes back only to the agent of the Professional, never to a third party. Use get_request first to check that documents have actually arrived.";
+var registerDownloadDocuments = (server, api) => {
+  server.registerTool(
+    "download_documents",
+    {
+      title: "Collect the documents of a Document Request",
+      description: DOWNLOAD_DOCUMENTS_DESCRIPTION,
+      inputSchema: {
+        request_id: z4.uuid().describe("The Document Request whose collected files are wanted.")
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+    },
+    ({ request_id }) => runTool(async () => {
+      const zip = await api.getBinary(`/v1/requests/${request_id}/download-zip`);
+      const fileName = zip.fileName ?? `request-${request_id}.zip`;
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${fileName} \u2014 ${zip.bytes.byteLength} bytes, ${zip.contentType}. The archive follows as an embedded resource.`
+          },
+          {
+            type: "resource",
+            resource: {
+              uri: `dokutrak://requests/${request_id}/${encodeURIComponent(fileName)}`,
+              mimeType: zip.contentType,
+              blob: Buffer.from(zip.bytes).toString("base64")
+            }
+          }
+        ]
+      };
+    })
+  );
+};
+
+// src/tools/index.ts
+var TOOL_REGISTRARS = [
+  registerCreateRequest,
+  registerRequestReplacement,
+  registerGetRequest,
+  registerDownloadDocuments
+];
+
+// src/server.ts
+var SERVER_NAME = "dokutrak";
+var SERVER_VERSION = "0.1.0";
+function createServer(options) {
+  const api = createApiClient({
+    baseUrl: options.baseUrl,
+    apiKey: options.apiKey,
+    userAgent: `dokutrak-mcp/${SERVER_VERSION}`,
+    ...options.fetch && { fetch: options.fetch }
+  });
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    {
+      instructions: "DokuTrak collects documents from Clients on behalf of a Professional. These tools let the agent create a Document Request, chase the Client on rejected files, read where a request stands and collect the files. Approving or rejecting a document is the decision of the Professional and is not available here."
+    }
+  );
+  for (const register of TOOL_REGISTRARS) register(server, api);
+  return server;
+}
+
+// src/cli.ts
+async function main() {
+  let config;
+  try {
+    config = readConfig();
+  } catch (error) {
+    process.stderr.write(
+      `dokutrak-mcp: ${error instanceof ConfigError ? error.message : String(error)}
+`
+    );
+    process.exit(1);
+  }
+  const server = createServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  process.stderr.write(`dokutrak-mcp: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "dokutrak-mcp",
+  "mcpName": "io.github.Crackx17/dokutrak-mcp",
+  "version": "0.1.0",
+  "description": "MCP connector for DokuTrak: let your agent chase the documents.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "dokutrak-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "check": "npm run typecheck && npm run build && npm test",
+    "prepublishOnly": "npm run check",
+    "staging": "node scripts/staging-run.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Crackx17/dokutrak-mcp.git"
+  },
+  "homepage": "https://dokutrak.com",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "dokutrak",
+    "document-collection",
+    "claude"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.0"
+  }
+}