delinea-mcp 1.0.0

package/README.md

@@ -0,0 +1,19 @@
+# delinea-mcp
+
+Delinea Secret Server API: OAuth login, secret search, secret retrieval, folders.
+
+## Setup
+
+```bash
+export DELINEA_BASE_URL=...
+```
+
+Needs DELINEA_BASE_URL (e.g. https://tenant.secretservercloud.com) plus DELINEA_USERNAME and DELINEA_PASSWORD.
+
+## Tools
+
+- `search_secrets` — Search Delinea secrets by text across allowed vaults.
+- `get_secret` — Retrieve one Delinea secret with field values.
+- `list_folders` — Top-level Delinea secret folders.
+
+Part of [awesome-mcps](https://github.com/mrfentmen/awesome-mcps).

package/dist/api.d.ts

@@ -0,0 +1,7 @@
+export declare class DelineaError extends Error {
+    constructor(message: string);
+}
+export declare function errorMessage(e: unknown): string;
+export declare function searchSecrets(query: string): Promise<string>;
+export declare function getSecret(secretId: string): Promise<string>;
+export declare function listFolders(): Promise<string>;

package/dist/api.js

@@ -0,0 +1,74 @@
+export class DelineaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DelineaError";
+    }
+}
+export function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+const UA = { "User-Agent": "awesome-mcps/1.0" };
+function envStrict(name) {
+    const v = process.env[name];
+    if (!v)
+        throw new DelineaError(`Set the ${name} environment variable.`);
+    return v;
+}
+async function apiBase() {
+    return envStrict("DELINEA_BASE_URL").replace(/\/$/, "");
+}
+let cachedToken = "";
+async function authHeaders() {
+    if (!cachedToken) {
+        const base = await apiBase();
+        const res = await fetch(`${base}/oauth2/token`, {
+            method: "POST",
+            headers: { ...UA, "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ username: envStrict("DELINEA_USERNAME"), password: envStrict("DELINEA_PASSWORD"), grant_type: "password" }).toString(),
+        });
+        if (!res.ok)
+            throw new DelineaError(`Delinea login failed: HTTP ${res.status}`);
+        const data = (await res.json());
+        if (!data.access_token)
+            throw new DelineaError("Delinea login returned no token");
+        cachedToken = data.access_token;
+    }
+    return { Authorization: "Bearer " + cachedToken };
+}
+function pretty(data) {
+    const t = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    return t.length > 12000 ? t.slice(0, 12000) + "\n…(truncated)" : t;
+}
+async function req(url, init = {}) {
+    const res = await fetch(url, { headers: { ...UA, ...(await authHeaders()), ...(init.headers ?? {}) }, ...init });
+    const ct = res.headers.get("content-type") ?? "";
+    const data = ct.includes("json") ? await res.json() : await res.text();
+    if (!res.ok) {
+        const detail = typeof data === "string" ? data.slice(0, 300) : JSON.stringify(data).slice(0, 300);
+        throw new DelineaError(`HTTP ${res.status}: ${detail}`);
+    }
+    return data;
+}
+export async function searchSecrets(query) {
+    const base = await apiBase();
+    let url = `${base}/api/v1/secrets`;
+    const qs = new URLSearchParams();
+    qs.append("filter.searchText", String(query));
+    const qstr = qs.toString();
+    if (qstr)
+        url += (url.includes('?') ? '&' : '?') + qstr;
+    const data = await req(url);
+    return pretty(data);
+}
+export async function getSecret(secretId) {
+    const base = await apiBase();
+    let url = `${base}/api/v1/secrets/${encodeURIComponent(String(secretId))}`;
+    const data = await req(url);
+    return pretty(data);
+}
+export async function listFolders() {
+    const base = await apiBase();
+    let url = `${base}/api/v1/folders`;
+    const data = await req(url);
+    return pretty(data);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,56 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { errorMessage, searchSecrets, getSecret, listFolders, } from "./api.js";
+const text = (t) => ({ content: [{ type: "text", text: t }] });
+const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
+const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+export function createServer() {
+    const server = new McpServer({
+        name: "delinea-mcp",
+        version: "1.0.0",
+    });
+    server.registerTool("search_secrets", {
+        title: "Search secrets",
+        description: "Search Delinea secrets by text across allowed vaults.",
+        inputSchema: z.object({
+            query: z.string().describe("Search text"),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ query }) => {
+        try {
+            return text(await searchSecrets(query));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("get_secret", {
+        title: "Get secret",
+        description: "Retrieve one Delinea secret with field values.",
+        inputSchema: z.object({
+            secretId: z.string().describe("Secret id"),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ secretId }) => {
+        try {
+            return text(await getSecret(secretId));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("list_folders", {
+        title: "List folders",
+        description: "Top-level Delinea secret folders.",
+        inputSchema: z.object({}),
+        annotations: READ_ONLY,
+    }, async ({}) => {
+        try {
+            return text(await listFolders());
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    return server;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "delinea-mcp",
+  "version": "1.0.0",
+  "description": "Delinea Secret Server API: OAuth login, secret search, secret retrieval, folders.",
+  "type": "module",
+  "mcpName": "io.github.mrfentmen/delinea-mcp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mrfentmen/awesome-mcps.git"
+  },
+  "bin": {
+    "delinea-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "rm -rf dist && tsc -p tsconfig.json && node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "delinea",
+    "secrets",
+    "vault",
+    "security"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}