@martin4455/redmine-mcp-ro 0.3.0

package/dist/tool-validation.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+/** Validate against the same schemas advertised in tools/list, before any side effect. */
+export declare class ToolArgumentValidator {
+    private readonly validators;
+    constructor(tools: readonly Tool[]);
+    validate(name: string, input: unknown): Record<string, unknown>;
+}

package/dist/tool-validation.js

@@ -0,0 +1,20 @@
+import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+/** Validate against the same schemas advertised in tools/list, before any side effect. */
+export class ToolArgumentValidator {
+    validators = new Map();
+    constructor(tools) {
+        const provider = new AjvJsonSchemaValidator();
+        for (const tool of tools) {
+            this.validators.set(tool.name, provider.getValidator(tool.inputSchema));
+        }
+    }
+    validate(name, input) {
+        const validate = this.validators.get(name);
+        if (!validate)
+            throw new Error(`Unknown tool: ${name}`);
+        const result = validate(input);
+        if (!result.valid)
+            throw new Error(`Invalid arguments for ${name}: ${result.errorMessage}`);
+        return result.data;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,247 @@
+export interface RedmineConfig {
+    url: string;
+    apiKey: string;
+    requestTimeoutMs?: number;
+    maxAttachmentBytes?: number;
+    maxContentBytes?: number;
+    downloadDir?: string;
+}
+/** Persisted configuration contains references only; never URLs or API keys. */
+export interface RedmineProfile {
+    credentialId: string;
+}
+export type LocalSettings = Pick<RedmineConfig, 'requestTimeoutMs' | 'maxAttachmentBytes' | 'maxContentBytes' | 'downloadDir'>;
+export interface ConfigFile {
+    version: '3.0';
+    defaultProfile?: string;
+    profiles: Record<string, RedmineProfile>;
+    settings?: LocalSettings;
+}
+/** Read only by the explicit migration command. */
+export interface LegacyConfigFile {
+    version: '1.0';
+    defaultProfile?: string;
+    profiles: Record<string, {
+        url: string;
+        apiKey: string;
+    }>;
+    settings?: LocalSettings;
+}
+/** Both development variants used 2.0: with a local URL, or references only. */
+export interface LegacyReferenceConfigFile {
+    version: '2.0';
+    defaultProfile?: string;
+    profiles: Record<string, {
+        credentialId: string;
+        url?: string;
+    }>;
+    settings?: LocalSettings;
+}
+export type StoredConfigFile = ConfigFile | LegacyConfigFile | LegacyReferenceConfigFile;
+export interface CredentialStore {
+    get(id: string): Promise<string | null>;
+    set(id: string, value: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export interface RedmineAttachment {
+    id: number;
+    filename: string;
+    content_url?: string;
+    href_url?: string;
+    content_type?: string;
+}
+export interface AttachmentIssue {
+    attachments?: RedmineAttachment[];
+    description?: string;
+    journals?: Array<{
+        notes?: string;
+    }>;
+}
+export interface ParsedAttachment {
+    id: number;
+    filename: string;
+    url: string;
+    timestamp?: number;
+    version?: boolean;
+}
+export interface AttachmentDownloadOptions {
+    version?: boolean;
+    timestamp?: number;
+    fallbackFilename?: string;
+}
+export interface DownloadedAttachment {
+    filepath: string;
+    filename: string;
+    size: number;
+    content_type?: string;
+}
+export interface DownloadedIssueAttachment extends DownloadedAttachment {
+    attachment_id: number;
+    source?: 'api' | 'embedded';
+}
+export interface AttachmentContent {
+    filename: string;
+    content: string;
+    content_type?: string;
+    size: number;
+}
+export interface RedmineIssue {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    tracker: {
+        id: number;
+        name: string;
+    };
+    status: {
+        id: number;
+        name: string;
+        is_closed?: boolean;
+    };
+    priority: {
+        id: number;
+        name: string;
+    };
+    author: {
+        id: number;
+        name: string;
+    };
+    assigned_to?: {
+        id: number;
+        name: string;
+    };
+    subject: string;
+    description?: string;
+    start_date?: string;
+    due_date?: string;
+    done_ratio?: number;
+    is_private?: boolean;
+    estimated_hours?: number;
+    spent_hours?: number;
+    created_on: string;
+    updated_on: string;
+    closed_on?: string;
+    easy_sprint?: {
+        id: number;
+        name?: string;
+        due_date?: string;
+    };
+    easy_sprint_phase?: number;
+    easy_sprint_position?: number;
+    easy_story_points?: number;
+}
+export interface RedmineProject {
+    id: number;
+    name: string;
+    identifier: string;
+    description?: string;
+    homepage?: string;
+    status: number;
+    is_public?: boolean;
+    inherit_members?: boolean;
+    created_on: string;
+    updated_on: string;
+    parent?: {
+        id: number;
+        name: string;
+    };
+}
+export interface RedmineUser {
+    id: number;
+    login: string;
+    admin?: boolean;
+    firstname: string;
+    lastname: string;
+    mail?: string;
+    created_on: string;
+    updated_on: string;
+    last_login_on?: string;
+    passwd_changed_on?: string;
+    status?: number;
+}
+export interface RedmineTimeEntry {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    issue?: {
+        id: number;
+    };
+    user: {
+        id: number;
+        name: string;
+    };
+    activity: {
+        id: number;
+        name: string;
+    };
+    hours: number;
+    comments?: string;
+    spent_on: string;
+    created_on: string;
+    updated_on: string;
+}
+export interface RedmineVersion {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    name: string;
+    description?: string;
+    status: string;
+    due_date?: string;
+    sharing: string;
+    wiki_page_title?: string;
+    estimated_hours?: number;
+    spent_hours?: number;
+    created_on: string;
+    updated_on: string;
+}
+export interface RedmineNews {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    author: {
+        id: number;
+        name: string;
+    };
+    title: string;
+    summary?: string;
+    description?: string;
+    created_on: string;
+}
+export interface RedmineWikiPage {
+    title: string;
+    parent?: {
+        title: string;
+    };
+    text?: string;
+    version: number;
+    author: {
+        id: number;
+        name: string;
+    };
+    comments?: string;
+    created_on: string;
+    updated_on: string;
+}
+export interface PaginationParams {
+    offset?: number;
+    limit?: number;
+}
+export interface IssueFilterParams extends PaginationParams {
+    project_id?: number | string;
+    subproject_id?: string;
+    tracker_id?: number;
+    status_id?: number | string;
+    assigned_to_id?: number | string;
+    parent_id?: number;
+    query_id?: number;
+    sort?: string;
+}

package/dist/types.js

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

package/dist/user-resolver.d.ts

@@ -0,0 +1,24 @@
+import { RedmineClient } from './redmine-client.js';
+/**
+ * UserResolver helps resolve user names or emails to user IDs
+ */
+export declare class UserResolver {
+    private userCache;
+    private client;
+    constructor(client: RedmineClient);
+    /**
+     * Resolves a user identifier (name, email, or ID) to a numeric user ID
+     * @param userIdentifier - Can be:
+     *   - Numeric ID (returned as-is)
+     *   - "me" or "current" (returns current user ID)
+     *   - Email address
+     *   - Full name (First Last)
+     *   - Username
+     * @returns The numeric user ID or the original value if resolution fails
+     */
+    resolveUser(userIdentifier: string | number): Promise<string | number>;
+    /**
+     * Clear the user cache
+     */
+    clearCache(): void;
+}

package/dist/user-resolver.js

@@ -0,0 +1,140 @@
+import { safeErrorMessage } from './safe-error.js';
+/**
+ * UserResolver helps resolve user names or emails to user IDs
+ */
+export class UserResolver {
+    userCache = new Map();
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Resolves a user identifier (name, email, or ID) to a numeric user ID
+     * @param userIdentifier - Can be:
+     *   - Numeric ID (returned as-is)
+     *   - "me" or "current" (returns current user ID)
+     *   - Email address
+     *   - Full name (First Last)
+     *   - Username
+     * @returns The numeric user ID or the original value if resolution fails
+     */
+    async resolveUser(userIdentifier) {
+        // If it's already a number, return it
+        if (typeof userIdentifier === 'number') {
+            return userIdentifier;
+        }
+        // Convert to string and trim
+        const identifier = String(userIdentifier).trim();
+        // If it's empty, return it as-is
+        if (!identifier) {
+            return identifier;
+        }
+        // Handle special values
+        if (identifier.toLowerCase() === 'me' || identifier.toLowerCase() === 'current') {
+            try {
+                const currentUser = await this.client.getCurrentUser();
+                return currentUser.id;
+            }
+            catch (error) {
+                console.error('Failed to get current user:', safeErrorMessage(error));
+                return identifier;
+            }
+        }
+        // If it's a numeric string, return it as number
+        if (/^\d+$/.test(identifier)) {
+            return parseInt(identifier, 10);
+        }
+        // Check cache first
+        if (this.userCache.has(identifier)) {
+            return this.userCache.get(identifier);
+        }
+        // Try to find user by name or email
+        try {
+            // First, try to get all users (requires admin privileges)
+            // If this fails, we'll fall back to other methods
+            const users = await this.client.getUsers({ limit: 100 });
+            for (const user of users.users) {
+                // Check by email (exact match)
+                if (user.mail && user.mail.toLowerCase() === identifier.toLowerCase()) {
+                    this.userCache.set(identifier, user.id);
+                    return user.id;
+                }
+                // Check by full name (case-insensitive)
+                const fullName = `${user.firstname} ${user.lastname}`.toLowerCase();
+                if (fullName === identifier.toLowerCase()) {
+                    this.userCache.set(identifier, user.id);
+                    return user.id;
+                }
+                // Check by login/username (case-insensitive)
+                if (user.login && user.login.toLowerCase() === identifier.toLowerCase()) {
+                    this.userCache.set(identifier, user.id);
+                    return user.id;
+                }
+            }
+        }
+        catch (error) {
+            // If we can't list users (not admin), try using time_entries API
+            console.error('Cannot list users (requires admin). Trying time_entries API...');
+            try {
+                // Get recent time entries to build a user mapping
+                // This doesn't require admin privileges!
+                const timeEntries = await this.client.getTimeEntries({ limit: 100 });
+                // Build a map of user names to IDs from time entries
+                for (const entry of timeEntries.time_entries) {
+                    if (entry.user) {
+                        const userName = entry.user.name;
+                        const userId = entry.user.id;
+                        // Store in cache for future use
+                        if (userName && !this.userCache.has(userName)) {
+                            this.userCache.set(userName, userId);
+                        }
+                        // Check if this matches what we're looking for
+                        if (userName && userName.toLowerCase() === identifier.toLowerCase()) {
+                            return userId;
+                        }
+                    }
+                }
+                // Also try to get issues to find more users (authors, assignees)
+                try {
+                    const issues = await this.client.getIssues({ limit: 100 });
+                    for (const issue of issues.issues) {
+                        // Check author
+                        if (issue.author && issue.author.name) {
+                            if (!this.userCache.has(issue.author.name)) {
+                                this.userCache.set(issue.author.name, issue.author.id);
+                            }
+                            if (issue.author.name.toLowerCase() === identifier.toLowerCase()) {
+                                return issue.author.id;
+                            }
+                        }
+                        // Check assigned_to
+                        if (issue.assigned_to && issue.assigned_to.name) {
+                            if (!this.userCache.has(issue.assigned_to.name)) {
+                                this.userCache.set(issue.assigned_to.name, issue.assigned_to.id);
+                            }
+                            if (issue.assigned_to.name.toLowerCase() === identifier.toLowerCase()) {
+                                return issue.assigned_to.id;
+                            }
+                        }
+                    }
+                }
+                catch (issuesError) {
+                    console.error('Could not fetch issues for user resolution:', safeErrorMessage(issuesError));
+                }
+            }
+            catch (timeEntriesError) {
+                console.error('Time entries lookup also failed:', safeErrorMessage(timeEntriesError));
+            }
+        }
+        // If we couldn't resolve it, return the original identifier
+        // This will likely cause an API error, but at least we tried
+        console.error('Could not resolve user identifier.');
+        return identifier;
+    }
+    /**
+     * Clear the user cache
+     */
+    clearCache() {
+        this.userCache.clear();
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@martin4455/redmine-mcp-ro",
+  "version": "0.3.0",
+  "description": "Model Context Protocol server for read-only access to Redmine REST API",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:integration": "npm run build && node test/run-automated-test.js",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit",
+    "check:package": "node scripts/check-package.mjs",
+    "prepack": "npm run build && npm run check:package",
+    "configure": "node dist/cli.js configure",
+    "config:status": "node dist/cli.js status",
+    "config:list": "node dist/cli.js list",
+    "config:migrate": "node dist/cli.js migrate",
+    "test:keyring": "npm run build && node scripts/test-keyring.mjs",
+    "test:keyring:ubuntu": "npm run build && docker build -t redmine-mcp-keyring-test -f test/keyring/Dockerfile . && docker run --rm redmine-mcp-keyring-test"
+  },
+  "bin": {
+    "redmine-mcp-ro": "dist/index.js",
+    "redmine-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts",
+    "README.md",
+    "CONFIG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "redmine",
+    "api",
+    "claude",
+    "ai"
+  ],
+  "author": "martin4455",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.31.0",
+    "@napi-rs/keyring": "2.1.0",
+    "axios": "1.20.0",
+    "chalk": "6.0.1",
+    "commander": "15.0.0",
+    "inquirer": "14.2.2",
+    "jsdom": "30.1.1"
+  },
+  "devDependencies": {
+    "@types/jsdom": "^30.0.0",
+    "@types/node": "^24.19.0",
+    "@typescript-eslint/eslint-plugin": "^8.71.0",
+    "@typescript-eslint/parser": "^8.71.0",
+    "eslint": "^10.11.0",
+    "tsx": "^4.23.15",
+    "typescript": "~6.0.3",
+    "vitest": "^5.0.3"
+  },
+  "engines": {
+    "node": "^24.15.0 || >=26.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luskan/redmine-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/luskan/redmine-mcp/issues"
+  },
+  "homepage": "https://github.com/luskan/redmine-mcp#readme"
+}