@sladd-no/mcp 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# @sladd-no/mcp
+
+**MCP server for [Sladd](https://sladd.no) — detect and redact Norwegian PII before documents leave your agent pipeline.**
+
+Sladd finds and removes Norwegian personally identifiable information — fodselsnummer (national IDs, checksum-validated), names, addresses, phone numbers, bank accounts, health information (GDPR Article 9), DUF numbers and more — in plain text and PDFs. This package exposes that capability to any MCP-compatible agent (Claude Desktop, Claude Code, Cursor, VS Code, custom agents) as two tools:
+
+| Tool | What it does |
+|---|---|
+| `detect_pii` | Scan text or a PDF → structured list of findings (type, offsets, confidence, recommended action) |
+| `redact_document` | Text → `redacted_text` with labels/pseudonyms. PDF → new PDF with findings irreversibly removed under black boxes, plus a verification block proving everything detected is gone |
+
+Use it as a guard: **redact first, then let the content continue through the agent flow.**
+
+## Setup in 30 seconds (Claude Desktop)
+
+Add this to `claude_desktop_config.json` (Settings → Developer → Edit Config):
+
+```json
+{
+  "mcpServers": {
+    "sladd": {
+      "command": "npx",
+      "args": ["-y", "@sladd-no/mcp"],
+      "env": { "SLADD_API_KEY": "sk_sladd_..." }
+    }
+  }
+}
+```
+
+On Windows, if `npx` is not found, use `"command": "cmd", "args": ["/c", "npx", "-y", "@sladd-no/mcp"]`.
+
+Restart Claude Desktop. Then try: *"Check vedtak.pdf on my desktop for Norwegian PII, and give me a redacted copy."*
+
+**Claude Code:**
+
+```bash
+claude mcp add sladd --env SLADD_API_KEY=sk_sladd_... -- npx -y @sladd-no/mcp
+```
+
+Need a key? API keys (`sk_sladd_...`) are issued at [sladd.no/api](https://sladd.no/api).
+
+## Remote endpoint (no install)
+
+For clients that support Streamable HTTP with custom headers (Claude Code, Cursor, VS Code, programmatic agents):
+
+```
+URL:    https://sladd.no/mcp
+Header: Authorization: Bearer sk_sladd_...
+```
+
+```bash
+claude mcp add --transport http sladd https://sladd.no/mcp --header "Authorization: Bearer sk_sladd_..."
+```
+
+Note: claude.ai web connectors require OAuth and are not supported yet. The remote endpoint accepts base64 PDFs up to ~3 MB per request; for larger files use the local install (`file_path` input has a 20 MB limit).
+
+## How PDFs flow (local install)
+
+The local server accepts a `file_path` — the agent never has to base64 a document through its context window:
+
+1. The server reads the PDF from disk and sends it to the Sladd API over HTTPS.
+2. The API detects, redacts (rasterized black boxes — underlying text deleted), re-scans its own output, and returns the verified PDF.
+3. The server writes `<name> [sladd].pdf` next to the input (never overwriting anything) and returns the path + verification report.
+
+The document content never enters the model's context — only the findings and the report do.
+
+## Privacy
+
+The hosted API processes documents **in memory only**: never written to disk, never queued, never logged. Usage metering records metadata only (document/page counts, mode) — never content, findings text, or filenames. See [sladd.no/personvern](https://sladd.no/personvern). For full data control, the same engine is available as a self-hosted Docker image and CLI.
+
+## Limits
+
+- Max 20 MB and 100 pages per document (remote endpoint: ~3 MB effective for base64 PDFs)
+- 60 requests per minute per key
+- `mode: "deep"` (NER layer, higher recall) is rolling out — until active it returns `mode_unavailable`; use the default `fast`
+
+## License
+
+Proprietary. © Sladd — [sladd.no](https://sladd.no). Contact: [sladd.no/om](https://sladd.no/om).

package/dist/index.mjs

@@ -0,0 +1,404 @@
+// packages/sladd-mcp/src/tools.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join } from "node:path";
+import { z } from "zod";
+
+// packages/sladd-mcp/src/client.ts
+var MAX_BYTES = 20 * 1024 * 1024;
+var TIMEOUT_MS = 11e4;
+var SladdApiError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = "SladdApiError";
+    this.code = code;
+    this.status = status;
+  }
+};
+function endpoint(apiBase, path) {
+  return `${apiBase.replace(/\/$/, "")}/api/v1/${path}`;
+}
+async function throwApiError(res) {
+  let code = "internal_error";
+  let message = `Uventet svar fra Sladd API (HTTP ${res.status}).`;
+  try {
+    const body = await res.json();
+    if (typeof body.code === "string") code = body.code;
+    if (typeof body.message === "string") message = body.message;
+  } catch {
+  }
+  throw new SladdApiError(code, message, res.status);
+}
+async function postJson(url, apiKey, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  if (!res.ok) await throwApiError(res);
+  return res;
+}
+async function postPdf(url, apiKey, bytes, filename, fields) {
+  const form = new FormData();
+  form.append("file", new File([bytes], filename ?? "document.pdf", { type: "application/pdf" }));
+  for (const [key, value] of Object.entries(fields)) form.append(key, value);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { authorization: `Bearer ${apiKey}` },
+    body: form,
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  if (!res.ok) await throwApiError(res);
+  return res;
+}
+function commonFields(params) {
+  const fields = {};
+  if (params.mode) fields.mode = params.mode;
+  if (params.types?.length) fields.types = params.types.join(",");
+  return fields;
+}
+async function detectText(opts, text, params) {
+  const body = { text, ...commonFields(params) };
+  if (params.types?.length) body.types = params.types;
+  const res = await postJson(endpoint(opts.apiBase, "detect"), opts.apiKey, body);
+  return await res.json();
+}
+async function detectPdf(opts, bytes, filename, params) {
+  const res = await postPdf(endpoint(opts.apiBase, "detect"), opts.apiKey, bytes, filename, commonFields(params));
+  return await res.json();
+}
+async function redactText(opts, text, params) {
+  const body = { text, ...commonFields(params) };
+  if (params.types?.length) body.types = params.types;
+  if (params.style) body.style = params.style;
+  const res = await postJson(endpoint(opts.apiBase, "redact"), opts.apiKey, body);
+  return await res.json();
+}
+async function redactPdf(opts, bytes, params) {
+  const fields = commonFields(params);
+  if (params.filenameCheck) fields.filename_check = "true";
+  const res = await postPdf(endpoint(opts.apiBase, "redact"), opts.apiKey, bytes, params.filename, fields);
+  const reportB64 = res.headers.get("x-sladd-report");
+  if (!reportB64) {
+    throw new SladdApiError("internal_error", "Svaret manglet X-Sladd-Report-headeren.", 500);
+  }
+  const report = JSON.parse(Buffer.from(reportB64, "base64").toString("utf8"));
+  return {
+    pdfBytes: new Uint8Array(await res.arrayBuffer()),
+    report,
+    filename: parseFilename(res.headers.get("content-disposition"))
+  };
+}
+function parseFilename(header) {
+  if (!header) return void 0;
+  const star = /filename\*=UTF-8''([^;]+)/i.exec(header);
+  if (star) {
+    try {
+      return decodeURIComponent(star[1].trim());
+    } catch {
+    }
+  }
+  const plain = /filename="([^"]+)"/i.exec(header);
+  return plain ? plain[1] : void 0;
+}
+
+// packages/sladd-mcp/src/types.ts
+var PII_TYPES = [
+  "PERSON_NAME",
+  "NATIONAL_ID",
+  "BANK_ACCOUNT",
+  "PHONE",
+  "EMAIL",
+  "ADDRESS",
+  "POSTAL_CODE",
+  "CASE_NUMBER",
+  "ORG_NUMBER",
+  "DATE_OF_BIRTH",
+  "DATE",
+  "LICENSE_PLATE",
+  "HEALTH_ID",
+  "HEALTH_INFO",
+  "DUF_NUMBER",
+  "OTHER"
+];
+
+// packages/sladd-mcp/src/tools.ts
+var MCP_SERVER_NAME = "sladd";
+var MCP_SERVER_VERSION = "0.1.0";
+var ToolError = class extends Error {
+};
+var ERROR_HINTS = {
+  invalid_key: "The API key was missing or rejected. Configure SLADD_API_KEY (local server) or the Authorization: Bearer header (remote). Keys look like sk_sladd_...",
+  rate_limited: "The limit is 60 requests per minute per key \u2014 wait briefly and retry.",
+  mode_unavailable: "deep mode is not available yet \u2014 retry with mode: 'fast'.",
+  too_large: "Documents are limited to 20 MB.",
+  could_not_parse: "The PDF could not be parsed \u2014 it may be corrupt, scanned without a text layer, or exceed 100 pages."
+};
+function errorResult(err) {
+  let text;
+  if (err instanceof SladdApiError) {
+    const hint = ERROR_HINTS[err.code];
+    text = `Sladd API error ${err.code}: ${err.message}${hint ? ` \u2014 ${hint}` : ""}`;
+  } else if (err instanceof ToolError) {
+    text = err.message;
+  } else if (err instanceof Error && err.name === "TimeoutError") {
+    text = "The Sladd API request timed out (110 s). Large scanned PDFs can be slow \u2014 try a smaller document.";
+  } else {
+    text = "Unexpected error while calling the Sladd API.";
+  }
+  return { isError: true, content: [{ type: "text", text }] };
+}
+function resolveInput(args, allowFilePaths) {
+  const provided = [
+    args.text ? "text" : null,
+    args.document_base64 ? "document_base64" : null,
+    args.file_path ? "file_path" : null
+  ].filter(Boolean);
+  const valid = allowFilePaths ? "text, document_base64 or file_path" : "text or document_base64";
+  if (provided.length !== 1) {
+    throw new ToolError(
+      `Provide exactly one input: ${valid}. Got ${provided.length ? provided.join(" + ") : "none"}.`
+    );
+  }
+  if (args.text) return { kind: "text", text: args.text };
+  if (args.document_base64) return { kind: "base64", base64: args.document_base64 };
+  if (!allowFilePaths) {
+    throw new ToolError(`file_path is not available on this server. Provide ${valid}.`);
+  }
+  return { kind: "file", path: args.file_path };
+}
+async function readLocalPdf(path) {
+  if (!isAbsolute(path)) {
+    throw new ToolError(`file_path must be an absolute path. Got: ${path}`);
+  }
+  let bytes;
+  try {
+    bytes = await readFile(path);
+  } catch {
+    throw new ToolError(`Could not read file: ${path}. Check that it exists and is readable.`);
+  }
+  if (bytes.length > MAX_BYTES) {
+    throw new ToolError(`File is ${(bytes.length / 1024 / 1024).toFixed(1)} MB \u2014 the limit is 20 MB.`);
+  }
+  const isPdf = bytes.length >= 5 && bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70 && bytes[4] === 45;
+  if (!isPdf) {
+    throw new ToolError(`${path} is not a PDF (missing %PDF header). For plain text, use the text input.`);
+  }
+  return { bytes: new Uint8Array(bytes), filename: basename(path) };
+}
+function decodeBase64Pdf(base64) {
+  let bytes;
+  try {
+    bytes = new Uint8Array(Buffer.from(base64, "base64"));
+  } catch {
+    throw new ToolError("document_base64 is not valid base64.");
+  }
+  if (bytes.length === 0) throw new ToolError("document_base64 decoded to an empty document.");
+  return bytes;
+}
+async function writeRedactedPdf(inputPath, outputPath, bytes) {
+  const target = outputPath ?? join(dirname(inputPath), `${basename(inputPath, extname(inputPath))} [sladd].pdf`);
+  const dir = dirname(target);
+  const stem = basename(target, extname(target));
+  const ext = extname(target) || ".pdf";
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const candidate = attempt === 0 ? target : join(dir, `${stem}-${attempt + 1}${ext}`);
+    try {
+      await writeFile(candidate, bytes, { flag: "wx" });
+      return candidate;
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw new ToolError(`Could not write the redacted PDF to ${candidate}.`);
+    }
+  }
+  throw new ToolError(`Could not find a free output filename near ${target}.`);
+}
+function okResult(structured, extraContent) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(structured, null, 2) }, ...extraContent ?? []],
+    structuredContent: structured
+  };
+}
+function inputTrio(allowFilePaths) {
+  const alternatives = allowFilePaths ? "text, document_base64, file_path" : "text, document_base64";
+  return {
+    text: z.string().optional().describe(`Raw text to scan (Norwegian or mixed-language). Provide exactly one of: ${alternatives}.`),
+    document_base64: z.string().optional().describe(
+      "A PDF encoded as base64." + (allowFilePaths ? " Prefer file_path for local files \u2014 base64 is token-expensive." : " Max ~3 MB over the hosted endpoint.")
+    ),
+    ...allowFilePaths ? {
+      file_path: z.string().optional().describe(
+        "Absolute path to a local PDF. The file is read from disk and sent to the Sladd API over HTTPS; its content never enters the conversation except as results."
+      )
+    } : {},
+    types: z.array(z.enum(PII_TYPES)).optional().describe("Limit to these PII types. Default: all 16 types."),
+    mode: z.enum(["fast", "deep"]).optional().describe(
+      "fast (default): regex + wordlist layers \u2014 deterministic, quick. deep: adds a Norwegian NER model for higher recall; if unavailable, retry with fast."
+    )
+  };
+}
+var detectionOutput = z.object({
+  start: z.number(),
+  end: z.number(),
+  text: z.string(),
+  type: z.string(),
+  confidence: z.number(),
+  sources: z.array(z.string()),
+  action: z.string()
+}).passthrough();
+var verificationOutput = z.object({ passed: z.boolean(), method: z.string(), leaks: z.array(z.unknown()) }).passthrough();
+function registerSladdTools(server, opts) {
+  const requireKey = (extra) => {
+    const key = opts.getApiKey(extra);
+    if (!key) {
+      throw new SladdApiError("invalid_key", "Ingen API-n\xF8kkel konfigurert.", 401);
+    }
+    return key;
+  };
+  server.registerTool(
+    "detect_pii",
+    {
+      title: "Detect Norwegian PII in text or a PDF",
+      description: "Scan text or a PDF for Norwegian personally identifiable information (PII) and get a structured list of findings. Detects 16 categories tuned to Norwegian formats with checksum validation: person names, national identity numbers (fodselsnummer/D-nummer), bank accounts, phone numbers, email addresses, street addresses, postal codes, case numbers (saksnummer), organization numbers, dates of birth, license plates, health identifiers and health information (GDPR Article 9 special-category data), and DUF numbers (immigration cases).\n\nUse this BEFORE pasting, summarizing, translating, or forwarding Norwegian documents \u2014 case files (vedtak), medical notes (journalnotat), CVs, letters, emails \u2014 to any LLM, external API, or third party. Norwegian documents routinely contain fodselsnummer or health data that trigger GDPR obligations, and generic regexes miss the Norwegian formats this service validates. Each detection includes character offsets, the matched text verbatim, PII type, confidence (0-1), and a recommended action (auto/review/hint). This tool only reports \u2014 it does not modify anything. To actually remove the PII, use redact_document.",
+      inputSchema: inputTrio(opts.allowFilePaths),
+      outputSchema: {
+        mode: z.string(),
+        pages: z.number(),
+        total: z.number().describe("Number of detections."),
+        detections: z.array(detectionOutput)
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args, extra) => {
+      try {
+        const apiKey = requireKey(extra);
+        const client = { apiBase: opts.apiBase, apiKey };
+        const params = { mode: args.mode, types: args.types };
+        const input = resolveInput(args, opts.allowFilePaths);
+        let response;
+        if (input.kind === "text") {
+          response = await detectText(client, input.text, params);
+        } else if (input.kind === "base64") {
+          response = await detectPdf(client, decodeBase64Pdf(input.base64), void 0, params);
+        } else {
+          const { bytes, filename } = await readLocalPdf(input.path);
+          response = await detectPdf(client, bytes, filename, params);
+        }
+        return okResult({
+          mode: response.mode,
+          pages: response.pages,
+          total: response.detections.length,
+          detections: response.detections
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "redact_document",
+    {
+      title: "Redact (sladd) Norwegian PII from text or a PDF",
+      description: "Remove Norwegian personally identifiable information from text or a PDF and get back a safe artifact plus a machine-readable verification report. Use this whenever a Norwegian document must be shared, archived, published (offentleglova/innsyn), or sent to an LLM or third party without exposing PII such as fodselsnummer, names, addresses, health information (GDPR Article 9), or bank details.\n\nText input returns redacted_text with each finding replaced by a type label ([Personnavn]) or a consistent pseudonym ([PERSON_1]) that preserves who-did-what readability. PDF input produces a new PDF where findings are irreversibly removed and covered with black boxes \u2014 the underlying text is deleted, not just hidden. Every response includes a verification block: the service re-scans the OUTPUT document and confirms that everything it detected is gone (verification.passed = true; a redaction that leaks fails instead of being returned). The report never contains the original PII text. Prefer this over manual find-and-replace: it validates Norwegian ID checksums, uses Norwegian name and health-term lists, and verifies its own output.",
+      inputSchema: {
+        ...inputTrio(opts.allowFilePaths),
+        style: z.enum(["label", "pseudonym"]).optional().describe(
+          "Text redaction style. label: '[Personnavn]'. pseudonym: '[PERSON_1]' (consistent across the document). PDFs always use irreversible black boxes; style is ignored for PDF input."
+        ),
+        filename_check: z.boolean().optional().describe(
+          "Also check whether the PDF's filename itself contains PII (e.g. 'vedtak-Ola-Hansen.pdf') and report it."
+        ),
+        ...opts.allowFilePaths ? {
+          output_path: z.string().optional().describe(
+            "Where to write the redacted PDF. Default: next to the input as '<name> [sladd].pdf'. Never overwrites an existing file (a numeric suffix is added instead)."
+          )
+        } : {}
+      },
+      outputSchema: {
+        redacted_text: z.string().optional().describe("Present for text input."),
+        output_file: z.string().optional().describe("Path to the redacted PDF (local file input)."),
+        stats: z.object({}).passthrough().optional(),
+        verification: verificationOutput,
+        report: z.object({}).passthrough().optional()
+      },
+      annotations: {
+        readOnlyHint: !opts.allowFilePaths,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (args, extra) => {
+      try {
+        const apiKey = requireKey(extra);
+        const client = { apiBase: opts.apiBase, apiKey };
+        const input = resolveInput(args, opts.allowFilePaths);
+        if (input.kind === "text") {
+          const response = await redactText(client, input.text, {
+            mode: args.mode,
+            types: args.types,
+            style: args.style
+          });
+          return okResult({
+            redacted_text: response.redacted_text,
+            verification: response.report.verification,
+            report: response.report
+          });
+        }
+        const pdfParams = {
+          mode: args.mode,
+          types: args.types,
+          filenameCheck: args.filename_check
+        };
+        if (input.kind === "file") {
+          const { bytes: bytes2, filename } = await readLocalPdf(input.path);
+          const result2 = await redactPdf(client, bytes2, { ...pdfParams, filename });
+          const outputFile = await writeRedactedPdf(input.path, args.output_path, result2.pdfBytes);
+          return okResult({
+            output_file: outputFile,
+            stats: result2.report.stats,
+            verification: result2.report.verification,
+            report: result2.report
+          });
+        }
+        const bytes = decodeBase64Pdf(input.base64);
+        const result = await redactPdf(client, bytes, pdfParams);
+        const structured = {
+          stats: result.report.stats,
+          verification: result.report.verification,
+          report: result.report
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Redacted PDF attached as a resource (${result.filename ?? "document [sladd].pdf"}). ` + JSON.stringify({ stats: result.report.stats, verification: result.report.verification })
+            },
+            {
+              type: "resource",
+              resource: {
+                uri: `sladd://redacted/${encodeURIComponent(result.filename ?? "document [sladd].pdf")}`,
+                mimeType: "application/pdf",
+                blob: Buffer.from(result.pdfBytes).toString("base64")
+              }
+            }
+          ],
+          structuredContent: structured
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+export {
+  MAX_BYTES,
+  MCP_SERVER_NAME,
+  MCP_SERVER_VERSION,
+  PII_TYPES,
+  SladdApiError,
+  registerSladdTools
+};

package/dist/stdio.mjs

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+// packages/sladd-mcp/src/stdio.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// packages/sladd-mcp/src/tools.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join } from "node:path";
+import { z } from "zod";
+
+// packages/sladd-mcp/src/client.ts
+var MAX_BYTES = 20 * 1024 * 1024;
+var TIMEOUT_MS = 11e4;
+var SladdApiError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = "SladdApiError";
+    this.code = code;
+    this.status = status;
+  }
+};
+function endpoint(apiBase2, path) {
+  return `${apiBase2.replace(/\/$/, "")}/api/v1/${path}`;
+}
+async function throwApiError(res) {
+  let code = "internal_error";
+  let message = `Uventet svar fra Sladd API (HTTP ${res.status}).`;
+  try {
+    const body = await res.json();
+    if (typeof body.code === "string") code = body.code;
+    if (typeof body.message === "string") message = body.message;
+  } catch {
+  }
+  throw new SladdApiError(code, message, res.status);
+}
+async function postJson(url, apiKey2, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey2}`
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  if (!res.ok) await throwApiError(res);
+  return res;
+}
+async function postPdf(url, apiKey2, bytes, filename, fields) {
+  const form = new FormData();
+  form.append("file", new File([bytes], filename ?? "document.pdf", { type: "application/pdf" }));
+  for (const [key, value] of Object.entries(fields)) form.append(key, value);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { authorization: `Bearer ${apiKey2}` },
+    body: form,
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  if (!res.ok) await throwApiError(res);
+  return res;
+}
+function commonFields(params) {
+  const fields = {};
+  if (params.mode) fields.mode = params.mode;
+  if (params.types?.length) fields.types = params.types.join(",");
+  return fields;
+}
+async function detectText(opts, text, params) {
+  const body = { text, ...commonFields(params) };
+  if (params.types?.length) body.types = params.types;
+  const res = await postJson(endpoint(opts.apiBase, "detect"), opts.apiKey, body);
+  return await res.json();
+}
+async function detectPdf(opts, bytes, filename, params) {
+  const res = await postPdf(endpoint(opts.apiBase, "detect"), opts.apiKey, bytes, filename, commonFields(params));
+  return await res.json();
+}
+async function redactText(opts, text, params) {
+  const body = { text, ...commonFields(params) };
+  if (params.types?.length) body.types = params.types;
+  if (params.style) body.style = params.style;
+  const res = await postJson(endpoint(opts.apiBase, "redact"), opts.apiKey, body);
+  return await res.json();
+}
+async function redactPdf(opts, bytes, params) {
+  const fields = commonFields(params);
+  if (params.filenameCheck) fields.filename_check = "true";
+  const res = await postPdf(endpoint(opts.apiBase, "redact"), opts.apiKey, bytes, params.filename, fields);
+  const reportB64 = res.headers.get("x-sladd-report");
+  if (!reportB64) {
+    throw new SladdApiError("internal_error", "Svaret manglet X-Sladd-Report-headeren.", 500);
+  }
+  const report = JSON.parse(Buffer.from(reportB64, "base64").toString("utf8"));
+  return {
+    pdfBytes: new Uint8Array(await res.arrayBuffer()),
+    report,
+    filename: parseFilename(res.headers.get("content-disposition"))
+  };
+}
+function parseFilename(header) {
+  if (!header) return void 0;
+  const star = /filename\*=UTF-8''([^;]+)/i.exec(header);
+  if (star) {
+    try {
+      return decodeURIComponent(star[1].trim());
+    } catch {
+    }
+  }
+  const plain = /filename="([^"]+)"/i.exec(header);
+  return plain ? plain[1] : void 0;
+}
+
+// packages/sladd-mcp/src/types.ts
+var PII_TYPES = [
+  "PERSON_NAME",
+  "NATIONAL_ID",
+  "BANK_ACCOUNT",
+  "PHONE",
+  "EMAIL",
+  "ADDRESS",
+  "POSTAL_CODE",
+  "CASE_NUMBER",
+  "ORG_NUMBER",
+  "DATE_OF_BIRTH",
+  "DATE",
+  "LICENSE_PLATE",
+  "HEALTH_ID",
+  "HEALTH_INFO",
+  "DUF_NUMBER",
+  "OTHER"
+];
+
+// packages/sladd-mcp/src/tools.ts
+var MCP_SERVER_NAME = "sladd";
+var MCP_SERVER_VERSION = "0.1.0";
+var ToolError = class extends Error {
+};
+var ERROR_HINTS = {
+  invalid_key: "The API key was missing or rejected. Configure SLADD_API_KEY (local server) or the Authorization: Bearer header (remote). Keys look like sk_sladd_...",
+  rate_limited: "The limit is 60 requests per minute per key \u2014 wait briefly and retry.",
+  mode_unavailable: "deep mode is not available yet \u2014 retry with mode: 'fast'.",
+  too_large: "Documents are limited to 20 MB.",
+  could_not_parse: "The PDF could not be parsed \u2014 it may be corrupt, scanned without a text layer, or exceed 100 pages."
+};
+function errorResult(err) {
+  let text;
+  if (err instanceof SladdApiError) {
+    const hint = ERROR_HINTS[err.code];
+    text = `Sladd API error ${err.code}: ${err.message}${hint ? ` \u2014 ${hint}` : ""}`;
+  } else if (err instanceof ToolError) {
+    text = err.message;
+  } else if (err instanceof Error && err.name === "TimeoutError") {
+    text = "The Sladd API request timed out (110 s). Large scanned PDFs can be slow \u2014 try a smaller document.";
+  } else {
+    text = "Unexpected error while calling the Sladd API.";
+  }
+  return { isError: true, content: [{ type: "text", text }] };
+}
+function resolveInput(args, allowFilePaths) {
+  const provided = [
+    args.text ? "text" : null,
+    args.document_base64 ? "document_base64" : null,
+    args.file_path ? "file_path" : null
+  ].filter(Boolean);
+  const valid = allowFilePaths ? "text, document_base64 or file_path" : "text or document_base64";
+  if (provided.length !== 1) {
+    throw new ToolError(
+      `Provide exactly one input: ${valid}. Got ${provided.length ? provided.join(" + ") : "none"}.`
+    );
+  }
+  if (args.text) return { kind: "text", text: args.text };
+  if (args.document_base64) return { kind: "base64", base64: args.document_base64 };
+  if (!allowFilePaths) {
+    throw new ToolError(`file_path is not available on this server. Provide ${valid}.`);
+  }
+  return { kind: "file", path: args.file_path };
+}
+async function readLocalPdf(path) {
+  if (!isAbsolute(path)) {
+    throw new ToolError(`file_path must be an absolute path. Got: ${path}`);
+  }
+  let bytes;
+  try {
+    bytes = await readFile(path);
+  } catch {
+    throw new ToolError(`Could not read file: ${path}. Check that it exists and is readable.`);
+  }
+  if (bytes.length > MAX_BYTES) {
+    throw new ToolError(`File is ${(bytes.length / 1024 / 1024).toFixed(1)} MB \u2014 the limit is 20 MB.`);
+  }
+  const isPdf = bytes.length >= 5 && bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70 && bytes[4] === 45;
+  if (!isPdf) {
+    throw new ToolError(`${path} is not a PDF (missing %PDF header). For plain text, use the text input.`);
+  }
+  return { bytes: new Uint8Array(bytes), filename: basename(path) };
+}
+function decodeBase64Pdf(base64) {
+  let bytes;
+  try {
+    bytes = new Uint8Array(Buffer.from(base64, "base64"));
+  } catch {
+    throw new ToolError("document_base64 is not valid base64.");
+  }
+  if (bytes.length === 0) throw new ToolError("document_base64 decoded to an empty document.");
+  return bytes;
+}
+async function writeRedactedPdf(inputPath, outputPath, bytes) {
+  const target = outputPath ?? join(dirname(inputPath), `${basename(inputPath, extname(inputPath))} [sladd].pdf`);
+  const dir = dirname(target);
+  const stem = basename(target, extname(target));
+  const ext = extname(target) || ".pdf";
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const candidate = attempt === 0 ? target : join(dir, `${stem}-${attempt + 1}${ext}`);
+    try {
+      await writeFile(candidate, bytes, { flag: "wx" });
+      return candidate;
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw new ToolError(`Could not write the redacted PDF to ${candidate}.`);
+    }
+  }
+  throw new ToolError(`Could not find a free output filename near ${target}.`);
+}
+function okResult(structured, extraContent) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(structured, null, 2) }, ...extraContent ?? []],
+    structuredContent: structured
+  };
+}
+function inputTrio(allowFilePaths) {
+  const alternatives = allowFilePaths ? "text, document_base64, file_path" : "text, document_base64";
+  return {
+    text: z.string().optional().describe(`Raw text to scan (Norwegian or mixed-language). Provide exactly one of: ${alternatives}.`),
+    document_base64: z.string().optional().describe(
+      "A PDF encoded as base64." + (allowFilePaths ? " Prefer file_path for local files \u2014 base64 is token-expensive." : " Max ~3 MB over the hosted endpoint.")
+    ),
+    ...allowFilePaths ? {
+      file_path: z.string().optional().describe(
+        "Absolute path to a local PDF. The file is read from disk and sent to the Sladd API over HTTPS; its content never enters the conversation except as results."
+      )
+    } : {},
+    types: z.array(z.enum(PII_TYPES)).optional().describe("Limit to these PII types. Default: all 16 types."),
+    mode: z.enum(["fast", "deep"]).optional().describe(
+      "fast (default): regex + wordlist layers \u2014 deterministic, quick. deep: adds a Norwegian NER model for higher recall; if unavailable, retry with fast."
+    )
+  };
+}
+var detectionOutput = z.object({
+  start: z.number(),
+  end: z.number(),
+  text: z.string(),
+  type: z.string(),
+  confidence: z.number(),
+  sources: z.array(z.string()),
+  action: z.string()
+}).passthrough();
+var verificationOutput = z.object({ passed: z.boolean(), method: z.string(), leaks: z.array(z.unknown()) }).passthrough();
+function registerSladdTools(server2, opts) {
+  const requireKey = (extra) => {
+    const key = opts.getApiKey(extra);
+    if (!key) {
+      throw new SladdApiError("invalid_key", "Ingen API-n\xF8kkel konfigurert.", 401);
+    }
+    return key;
+  };
+  server2.registerTool(
+    "detect_pii",
+    {
+      title: "Detect Norwegian PII in text or a PDF",
+      description: "Scan text or a PDF for Norwegian personally identifiable information (PII) and get a structured list of findings. Detects 16 categories tuned to Norwegian formats with checksum validation: person names, national identity numbers (fodselsnummer/D-nummer), bank accounts, phone numbers, email addresses, street addresses, postal codes, case numbers (saksnummer), organization numbers, dates of birth, license plates, health identifiers and health information (GDPR Article 9 special-category data), and DUF numbers (immigration cases).\n\nUse this BEFORE pasting, summarizing, translating, or forwarding Norwegian documents \u2014 case files (vedtak), medical notes (journalnotat), CVs, letters, emails \u2014 to any LLM, external API, or third party. Norwegian documents routinely contain fodselsnummer or health data that trigger GDPR obligations, and generic regexes miss the Norwegian formats this service validates. Each detection includes character offsets, the matched text verbatim, PII type, confidence (0-1), and a recommended action (auto/review/hint). This tool only reports \u2014 it does not modify anything. To actually remove the PII, use redact_document.",
+      inputSchema: inputTrio(opts.allowFilePaths),
+      outputSchema: {
+        mode: z.string(),
+        pages: z.number(),
+        total: z.number().describe("Number of detections."),
+        detections: z.array(detectionOutput)
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args, extra) => {
+      try {
+        const apiKey2 = requireKey(extra);
+        const client = { apiBase: opts.apiBase, apiKey: apiKey2 };
+        const params = { mode: args.mode, types: args.types };
+        const input = resolveInput(args, opts.allowFilePaths);
+        let response;
+        if (input.kind === "text") {
+          response = await detectText(client, input.text, params);
+        } else if (input.kind === "base64") {
+          response = await detectPdf(client, decodeBase64Pdf(input.base64), void 0, params);
+        } else {
+          const { bytes, filename } = await readLocalPdf(input.path);
+          response = await detectPdf(client, bytes, filename, params);
+        }
+        return okResult({
+          mode: response.mode,
+          pages: response.pages,
+          total: response.detections.length,
+          detections: response.detections
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.registerTool(
+    "redact_document",
+    {
+      title: "Redact (sladd) Norwegian PII from text or a PDF",
+      description: "Remove Norwegian personally identifiable information from text or a PDF and get back a safe artifact plus a machine-readable verification report. Use this whenever a Norwegian document must be shared, archived, published (offentleglova/innsyn), or sent to an LLM or third party without exposing PII such as fodselsnummer, names, addresses, health information (GDPR Article 9), or bank details.\n\nText input returns redacted_text with each finding replaced by a type label ([Personnavn]) or a consistent pseudonym ([PERSON_1]) that preserves who-did-what readability. PDF input produces a new PDF where findings are irreversibly removed and covered with black boxes \u2014 the underlying text is deleted, not just hidden. Every response includes a verification block: the service re-scans the OUTPUT document and confirms that everything it detected is gone (verification.passed = true; a redaction that leaks fails instead of being returned). The report never contains the original PII text. Prefer this over manual find-and-replace: it validates Norwegian ID checksums, uses Norwegian name and health-term lists, and verifies its own output.",
+      inputSchema: {
+        ...inputTrio(opts.allowFilePaths),
+        style: z.enum(["label", "pseudonym"]).optional().describe(
+          "Text redaction style. label: '[Personnavn]'. pseudonym: '[PERSON_1]' (consistent across the document). PDFs always use irreversible black boxes; style is ignored for PDF input."
+        ),
+        filename_check: z.boolean().optional().describe(
+          "Also check whether the PDF's filename itself contains PII (e.g. 'vedtak-Ola-Hansen.pdf') and report it."
+        ),
+        ...opts.allowFilePaths ? {
+          output_path: z.string().optional().describe(
+            "Where to write the redacted PDF. Default: next to the input as '<name> [sladd].pdf'. Never overwrites an existing file (a numeric suffix is added instead)."
+          )
+        } : {}
+      },
+      outputSchema: {
+        redacted_text: z.string().optional().describe("Present for text input."),
+        output_file: z.string().optional().describe("Path to the redacted PDF (local file input)."),
+        stats: z.object({}).passthrough().optional(),
+        verification: verificationOutput,
+        report: z.object({}).passthrough().optional()
+      },
+      annotations: {
+        readOnlyHint: !opts.allowFilePaths,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (args, extra) => {
+      try {
+        const apiKey2 = requireKey(extra);
+        const client = { apiBase: opts.apiBase, apiKey: apiKey2 };
+        const input = resolveInput(args, opts.allowFilePaths);
+        if (input.kind === "text") {
+          const response = await redactText(client, input.text, {
+            mode: args.mode,
+            types: args.types,
+            style: args.style
+          });
+          return okResult({
+            redacted_text: response.redacted_text,
+            verification: response.report.verification,
+            report: response.report
+          });
+        }
+        const pdfParams = {
+          mode: args.mode,
+          types: args.types,
+          filenameCheck: args.filename_check
+        };
+        if (input.kind === "file") {
+          const { bytes: bytes2, filename } = await readLocalPdf(input.path);
+          const result2 = await redactPdf(client, bytes2, { ...pdfParams, filename });
+          const outputFile = await writeRedactedPdf(input.path, args.output_path, result2.pdfBytes);
+          return okResult({
+            output_file: outputFile,
+            stats: result2.report.stats,
+            verification: result2.report.verification,
+            report: result2.report
+          });
+        }
+        const bytes = decodeBase64Pdf(input.base64);
+        const result = await redactPdf(client, bytes, pdfParams);
+        const structured = {
+          stats: result.report.stats,
+          verification: result.report.verification,
+          report: result.report
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Redacted PDF attached as a resource (${result.filename ?? "document [sladd].pdf"}). ` + JSON.stringify({ stats: result.report.stats, verification: result.report.verification })
+            },
+            {
+              type: "resource",
+              resource: {
+                uri: `sladd://redacted/${encodeURIComponent(result.filename ?? "document [sladd].pdf")}`,
+                mimeType: "application/pdf",
+                blob: Buffer.from(result.pdfBytes).toString("base64")
+              }
+            }
+          ],
+          structuredContent: structured
+        };
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// packages/sladd-mcp/src/stdio.ts
+var apiKey = process.env.SLADD_API_KEY;
+if (!apiKey) {
+  console.error(
+    '@sladd-no/mcp: SLADD_API_KEY is not set.\nAdd it to the server config, e.g. in claude_desktop_config.json:\n  "env": { "SLADD_API_KEY": "sk_sladd_..." }\nKeys are issued at https://sladd.no/api'
+  );
+  process.exit(1);
+}
+var apiBase = process.env.SLADD_API_BASE ?? "https://sladd.no";
+var server = new McpServer({ name: MCP_SERVER_NAME, version: MCP_SERVER_VERSION });
+registerSladdTools(server, {
+  apiBase,
+  getApiKey: () => apiKey,
+  allowFilePaths: true
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`@sladd-no/mcp ${MCP_SERVER_VERSION} ready (API: ${apiBase})`);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@sladd-no/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Sladd — detect and redact Norwegian PII (fodselsnummer, names, health data) in text and PDFs before documents leave your agent pipeline. Thin client over the Sladd API.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "mcpName": "no.sladd/mcp",
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "sladd-mcp": "dist/stdio.mjs"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pii",
+    "redaction",
+    "gdpr",
+    "norwegian",
+    "fodselsnummer",
+    "anonymization",
+    "sladding"
+  ],
+  "author": "Sladd (https://sladd.no)",
+  "homepage": "https://sladd.no/api",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "cd ../.. && npm run build:mcp"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.26.0",
+    "zod": "^3.25.1"
+  }
+}