@pschroee/redmine-mcp 0.3.1

package/dist/redmine/types.d.ts

@@ -0,0 +1,489 @@
+export interface RedmineError {
+    error: true;
+    status: number;
+    message: string;
+}
+export type RedmineResult<T> = T | RedmineError;
+export interface RedmineCustomFieldValue {
+    id: number;
+    name: string;
+    value: string | string[];
+    multiple?: boolean;
+}
+export interface RedmineCustomField {
+    id: number;
+    name: string;
+    customized_type: string;
+    field_format: string;
+    regexp?: string;
+    min_length?: number;
+    max_length?: number;
+    is_required: boolean;
+    is_filter: boolean;
+    searchable: boolean;
+    multiple: boolean;
+    default_value?: string;
+    visible: boolean;
+    possible_values?: {
+        value: string;
+        label?: string;
+    }[];
+    trackers?: {
+        id: number;
+        name: string;
+    }[];
+    roles?: {
+        id: number;
+        name: string;
+    }[];
+}
+export interface RedmineCustomFieldsResponse {
+    custom_fields: RedmineCustomField[];
+}
+export interface RedmineTracker {
+    id: number;
+    name: string;
+    default_status?: {
+        id: number;
+        name: string;
+    };
+    description?: string;
+}
+export interface RedmineTrackersResponse {
+    trackers: RedmineTracker[];
+}
+export interface RedmineIssueStatus {
+    id: number;
+    name: string;
+    is_closed: boolean;
+}
+export interface RedmineIssueStatusesResponse {
+    issue_statuses: RedmineIssueStatus[];
+}
+export interface RedmineCategory {
+    id: number;
+    project?: {
+        id: number;
+        name: string;
+    };
+    name: string;
+    assigned_to?: {
+        id: number;
+        name: string;
+    };
+}
+export interface RedmineCategoriesResponse {
+    issue_categories: RedmineCategory[];
+}
+export interface RedmineActivity {
+    id: number;
+    name: string;
+    is_default: boolean;
+    active: boolean;
+}
+export interface RedmineQuery {
+    id: number;
+    name: string;
+    is_public: boolean;
+    project_id?: number;
+}
+export interface RedmineQueriesResponse {
+    queries: RedmineQuery[];
+}
+export interface RedmineAttachment {
+    id: number;
+    filename: string;
+    filesize: number;
+    content_type: string;
+    description?: string;
+    content_url: string;
+    thumbnail_url?: string;
+    author: {
+        id: number;
+        name: string;
+    };
+    created_on: string;
+}
+export interface RedmineUploadResponse {
+    upload: {
+        token: string;
+    };
+}
+export interface RedmineFile {
+    id: number;
+    filename: string;
+    filesize: number;
+    content_type: string;
+    description?: string;
+    content_url: string;
+    author: {
+        id: number;
+        name: string;
+    };
+    created_on: string;
+    version?: {
+        id: number;
+        name: string;
+    };
+    digest: string;
+    downloads: number;
+}
+export interface RedmineFilesResponse {
+    files: RedmineFile[];
+}
+export interface RedmineJournalDetail {
+    property: string;
+    name: string;
+    old_value?: string;
+    new_value?: string;
+}
+export interface RedmineJournal {
+    id: number;
+    user: {
+        id: number;
+        name: string;
+    };
+    notes?: string;
+    private_notes: boolean;
+    created_on: string;
+    details: RedmineJournalDetail[];
+}
+export interface RedmineChangeset {
+    revision: string;
+    user?: {
+        id: number;
+        name: string;
+    };
+    comments?: string;
+    committed_on: string;
+}
+export interface RedmineRelation {
+    id: number;
+    issue_id: number;
+    issue_to_id: number;
+    relation_type: string;
+    delay?: number;
+}
+export interface RedmineRelationsResponse {
+    relations: RedmineRelation[];
+}
+export interface RedmineVersion {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    name: string;
+    description?: string;
+    status: string;
+    sharing: string;
+    due_date?: string;
+    wiki_page_title?: string;
+    estimated_hours?: number;
+    spent_hours?: number;
+    created_on: string;
+    updated_on: string;
+}
+export interface RedmineVersionsResponse {
+    versions: RedmineVersion[];
+    total_count: 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;
+    };
+    category?: {
+        id: number;
+        name: string;
+    };
+    fixed_version?: {
+        id: number;
+        name: string;
+    };
+    parent?: {
+        id: number;
+    };
+    subject: string;
+    description?: string;
+    start_date?: string;
+    due_date?: string;
+    done_ratio?: number;
+    is_private?: boolean;
+    estimated_hours?: number;
+    spent_hours?: number;
+    total_estimated_hours?: number;
+    total_spent_hours?: number;
+    custom_fields?: RedmineCustomFieldValue[];
+    created_on: string;
+    updated_on: string;
+    closed_on?: string;
+    attachments?: RedmineAttachment[];
+    relations?: RedmineRelation[];
+    journals?: RedmineJournal[];
+    watchers?: {
+        id: number;
+        name: string;
+    }[];
+    children?: {
+        id: number;
+        tracker: {
+            id: number;
+            name: string;
+        };
+        subject: string;
+    }[];
+    changesets?: RedmineChangeset[];
+    allowed_statuses?: {
+        id: number;
+        name: string;
+    }[];
+}
+export interface RedmineIssuesResponse {
+    issues: RedmineIssue[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineProject {
+    id: number;
+    name: string;
+    identifier: string;
+    description?: string;
+    homepage?: string;
+    status: number;
+    is_public: boolean;
+    inherit_members?: boolean;
+    parent?: {
+        id: number;
+        name: string;
+    };
+    default_assigned_to?: {
+        id: number;
+        name: string;
+    };
+    default_version?: {
+        id: number;
+        name: string;
+    };
+    trackers?: RedmineTracker[];
+    issue_categories?: RedmineCategory[];
+    enabled_modules?: {
+        id: number;
+        name: string;
+    }[];
+    time_entry_activities?: RedmineActivity[];
+    issue_custom_fields?: RedmineCustomField[];
+    created_on: string;
+    updated_on: string;
+}
+export interface RedmineProjectsResponse {
+    projects: RedmineProject[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+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;
+    attachments?: RedmineAttachment[];
+}
+export interface RedmineWikiPageIndex {
+    title: string;
+    parent?: {
+        title: string;
+    };
+    version: number;
+}
+export interface RedmineWikiPagesResponse {
+    wiki_pages: RedmineWikiPageIndex[];
+}
+export interface RedmineSearchResult {
+    id: number;
+    title: string;
+    type: string;
+    url: string;
+    description: string;
+    datetime: string;
+}
+export interface RedmineSearchResponse {
+    results: RedmineSearchResult[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineMyAccount {
+    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;
+    twofa_scheme?: string;
+    api_key?: string;
+    status?: number;
+    custom_fields?: RedmineCustomFieldValue[];
+}
+export interface RedmineMyAccountResponse {
+    user: RedmineMyAccount;
+}
+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;
+    custom_fields?: RedmineCustomFieldValue[];
+}
+export interface RedmineTimeEntriesResponse {
+    time_entries: RedmineTimeEntry[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineEnumeration {
+    id: number;
+    name: string;
+    is_default: boolean;
+}
+export interface RedmineIssuePrioritiesResponse {
+    issue_priorities: RedmineEnumeration[];
+}
+export interface RedmineTimeEntryActivitiesResponse {
+    time_entry_activities: RedmineEnumeration[];
+}
+export interface RedmineDocumentCategoriesResponse {
+    document_categories: RedmineEnumeration[];
+}
+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;
+    api_key?: string;
+    status?: number;
+    custom_fields?: RedmineCustomFieldValue[];
+    memberships?: RedmineMembership[];
+    groups?: {
+        id: number;
+        name: string;
+    }[];
+}
+export interface RedmineUsersResponse {
+    users: RedmineUser[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineGroup {
+    id: number;
+    name: string;
+    users?: {
+        id: number;
+        name: string;
+    }[];
+    memberships?: RedmineMembership[];
+}
+export interface RedmineGroupsResponse {
+    groups: RedmineGroup[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineMembership {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    user?: {
+        id: number;
+        name: string;
+    };
+    group?: {
+        id: number;
+        name: string;
+    };
+    roles: {
+        id: number;
+        name: string;
+        inherited?: boolean;
+    }[];
+}
+export interface RedmineMembershipsResponse {
+    memberships: RedmineMembership[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface RedmineRole {
+    id: number;
+    name: string;
+    assignable?: boolean;
+    issues_visibility?: string;
+    time_entries_visibility?: string;
+    users_visibility?: string;
+    permissions?: string[];
+}
+export interface RedmineRolesResponse {
+    roles: RedmineRole[];
+}

package/dist/redmine/types.js

@@ -0,0 +1,2 @@
+// === COMMON TYPES ===
+export {};

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { RedmineClient } from "./redmine/client.js";
+import { type ToolGroup } from "./tools/index.js";
+export declare function createServer(redmineClient: RedmineClient, toolGroups: ToolGroup[]): McpServer;

package/dist/server.js

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools/index.js";
+export function createServer(redmineClient, toolGroups) {
+    const server = new McpServer({
+        name: "redmine-mcp",
+        version: "0.3.1",
+    });
+    registerTools(server, redmineClient, toolGroups);
+    return server;
+}

package/dist/tools/account.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerAccountTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/account.js

@@ -0,0 +1,10 @@
+export function registerAccountTools(server, client) {
+    server.registerTool("get_my_account", {
+        description: "Get current user account information",
+    }, async () => {
+        const result = await client.getMyAccount();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/admin.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerAdminTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/admin.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+export function registerAdminTools(server, client) {
+    // === USERS ===
+    server.registerTool("list_users", {
+        description: "List all users (admin only)",
+        inputSchema: {
+            status: z.number().optional().describe("Filter by status: 0=all, 1=active (default), 2=registered, 3=locked"),
+            name: z.string().optional().describe("Search in login, firstname, lastname, mail"),
+            group_id: z.number().optional().describe("Filter by group membership"),
+            limit: z.number().optional().describe("Maximum results"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const result = await client.listUsers(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_user", {
+        description: "Get user details by ID or 'current' for authenticated user",
+        inputSchema: {
+            user_id: z.union([z.number(), z.literal("current")]).describe("User ID or 'current'"),
+            include: z.string().optional().describe("Include: memberships, groups"),
+        },
+    }, async (params) => {
+        const result = await client.getUser(params.user_id, params.include);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_user", {
+        description: "Create a new user (admin only)",
+        inputSchema: {
+            login: z.string().describe("Login name (required)"),
+            firstname: z.string().describe("First name (required)"),
+            lastname: z.string().describe("Last name (required)"),
+            mail: z.string().describe("Email address (required)"),
+            password: z.string().optional().describe("Password (optional if generate_password=true)"),
+            generate_password: z.boolean().optional().describe("Generate random password"),
+            must_change_passwd: z.boolean().optional().describe("Force password change on first login"),
+            auth_source_id: z.number().optional().describe("External authentication source ID"),
+            mail_notification: z.string().optional().describe("Email notification preference"),
+            admin: z.boolean().optional().describe("Grant admin privileges"),
+            send_information: z.boolean().optional().describe("Send account info email to user"),
+        },
+    }, async (params) => {
+        const result = await client.createUser(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_user", {
+        description: "Update an existing user (admin only)",
+        inputSchema: {
+            user_id: z.number().describe("User ID to update"),
+            login: z.string().optional().describe("New login name"),
+            firstname: z.string().optional().describe("New first name"),
+            lastname: z.string().optional().describe("New last name"),
+            mail: z.string().optional().describe("New email address"),
+            password: z.string().optional().describe("New password"),
+            admin: z.boolean().optional().describe("Change admin status"),
+            status: z.number().optional().describe("Change status: 1=active, 2=registered, 3=locked"),
+        },
+    }, async (params) => {
+        const { user_id, ...data } = params;
+        const result = await client.updateUser(user_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_user", {
+        description: "Delete a user permanently (admin only)",
+        inputSchema: {
+            user_id: z.number().describe("User ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteUser(params.user_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    // === GROUPS ===
+    server.registerTool("list_groups", {
+        description: "List all groups (admin only)",
+    }, async () => {
+        const result = await client.listGroups();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_group", {
+        description: "Get group details (admin only)",
+        inputSchema: {
+            group_id: z.number().describe("Group ID"),
+            include: z.string().optional().describe("Include: users, memberships"),
+        },
+    }, async (params) => {
+        const result = await client.getGroup(params.group_id, params.include);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_group", {
+        description: "Create a new group (admin only)",
+        inputSchema: {
+            name: z.string().describe("Group name (required)"),
+            user_ids: z.array(z.number()).optional().describe("Initial member user IDs"),
+        },
+    }, async (params) => {
+        const result = await client.createGroup(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_group", {
+        description: "Delete a group (admin only)",
+        inputSchema: {
+            group_id: z.number().describe("Group ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteGroup(params.group_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("add_user_to_group", {
+        description: "Add a user to a group (admin only)",
+        inputSchema: {
+            group_id: z.number().describe("Group ID"),
+            user_id: z.number().describe("User ID to add"),
+        },
+    }, async (params) => {
+        const result = await client.addUserToGroup(params.group_id, params.user_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("remove_user_from_group", {
+        description: "Remove a user from a group (admin only)",
+        inputSchema: {
+            group_id: z.number().describe("Group ID"),
+            user_id: z.number().describe("User ID to remove"),
+        },
+    }, async (params) => {
+        const result = await client.removeUserFromGroup(params.group_id, params.user_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/dist/tools/core.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerCoreTools(server: McpServer, client: RedmineClient): void;