@martin4455/redmine-mcp-ro 0.3.0

package/dist/local-configuration.js

@@ -0,0 +1,218 @@
+import { randomUUID } from 'node:crypto';
+import { ConfigurationError, localConfigPath, normalizeRedmineUrl, readConfig, requireModern, validateProfileName, withConfigLock, writeConfig, } from './config-file.js';
+import { SystemCredentialStore } from './credential-store.js';
+function migratedProfileNames(names) {
+    const result = new Map();
+    // Reserve valid names first, independent of their order in the old file.
+    for (const name of names) {
+        try {
+            validateProfileName(name);
+            result.set(name, name);
+        }
+        catch { /* Rename legacy names below. */ }
+    }
+    const used = new Set(result.values());
+    for (const name of names) {
+        if (result.has(name))
+            continue;
+        let base = name.normalize('NFKD').replace(/\p{M}/gu, '').replace(/[^a-zA-Z0-9._-]+/g, '-')
+            .replace(/^[^a-zA-Z0-9]+/, '').slice(0, 64);
+        if (!base || ['constructor', 'prototype'].includes(base))
+            base = 'profile';
+        let target = base;
+        for (let suffix = 2; used.has(target); suffix++) {
+            const ending = `-${suffix}`;
+            target = base.slice(0, 64 - ending.length) + ending;
+        }
+        validateProfileName(target);
+        result.set(name, target);
+        used.add(target);
+    }
+    return result;
+}
+async function storeOperation(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError)
+            throw error;
+        throw new ConfigurationError('System credential operation failed. No plaintext fallback is used.');
+    }
+}
+export function validateApiKey(value) {
+    if (!value || value !== value.trim() || /[\r\n\0]/.test(value)) {
+        throw new ConfigurationError('API key must be nonempty and contain no surrounding whitespace or control line breaks.');
+    }
+}
+export function parseConnection(raw) {
+    if (raw === null)
+        throw new ConfigurationError('Credential not found in the system store. Configure this profile on this computer.');
+    try {
+        const payload = JSON.parse(raw);
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload) ||
+            Object.keys(payload).some(key => !['version', 'url', 'apiKey'].includes(key)) ||
+            payload.version !== 1 || typeof payload.url !== 'string' || typeof payload.apiKey !== 'string')
+            throw new Error();
+        validateApiKey(payload.apiKey);
+        return { url: normalizeRedmineUrl(payload.url), apiKey: payload.apiKey };
+    }
+    catch {
+        throw new ConfigurationError('Invalid credential in the system store. Reconfigure this profile.');
+    }
+}
+export async function readConnection(store, profile) {
+    return parseConnection(await storeOperation(() => store.get(profile.credentialId)));
+}
+export class LocalConfiguration {
+    configPath;
+    store;
+    legacyStore;
+    constructor(options = {}) {
+        this.configPath = localConfigPath(options.directory);
+        this.store = options.store ?? new SystemCredentialStore();
+        // Tests with an injected store never access the user's real keyring.
+        this.legacyStore = options.legacyStore ?? (options.store ? undefined : new SystemCredentialStore('legacy'));
+    }
+    read() {
+        const { config } = readConfig(this.configPath);
+        return config ? requireModern(config) : null;
+    }
+    async cleanup(ids) {
+        const warnings = [];
+        for (const id of ids) {
+            try {
+                await storeOperation(() => this.store.delete(id));
+            }
+            catch {
+                warnings.push(`Could not delete credential ${id} from the system store. Remove that entry manually from service @martin4455/redmine-mcp-ro.`);
+            }
+        }
+        return warnings;
+    }
+    async createCredential(url, apiKey) {
+        validateApiKey(apiKey);
+        const connection = { version: 1, url: normalizeRedmineUrl(url), apiKey };
+        const profile = { credentialId: randomUUID() };
+        const payload = JSON.stringify(connection);
+        try {
+            await storeOperation(() => this.store.set(profile.credentialId, payload));
+            const stored = await storeOperation(() => this.store.get(profile.credentialId));
+            if (stored === null)
+                throw new ConfigurationError('Credential not found after saving to the system store.');
+            if (stored !== payload) {
+                throw new ConfigurationError('Credential verification failed. Configuration was not saved.');
+            }
+            return profile;
+        }
+        catch (error) {
+            const warnings = await this.cleanup([profile.credentialId]);
+            if (warnings.length)
+                throw new ConfigurationError(`${error instanceof ConfigurationError ? error.message : 'Credential operation failed.'} ${warnings.join(' ')}`);
+            throw error;
+        }
+    }
+    async configure(name, url, apiKey) {
+        validateProfileName(name);
+        normalizeRedmineUrl(url);
+        validateApiKey(apiKey);
+        return withConfigLock(this.configPath, async () => {
+            const snapshot = readConfig(this.configPath);
+            const config = requireModern(snapshot.config);
+            const previous = config.profiles[name];
+            const profile = await this.createCredential(url, apiKey);
+            config.profiles[name] = profile;
+            config.defaultProfile ??= name;
+            try {
+                writeConfig(this.configPath, config, snapshot.raw);
+            }
+            catch (error) {
+                const warnings = await this.cleanup([profile.credentialId]);
+                if (warnings.length)
+                    throw new ConfigurationError(`Configuration was not saved. ${warnings.join(' ')}`);
+                throw error;
+            }
+            return { config, warnings: await this.cleanup(previous ? [previous.credentialId] : []) };
+        });
+    }
+    async migrate() {
+        return withConfigLock(this.configPath, async () => {
+            const snapshot = readConfig(this.configPath);
+            if (!snapshot.config)
+                throw new ConfigurationError('No local configuration to migrate.');
+            if (snapshot.config.version === '3.0')
+                return { config: snapshot.config, warnings: [] };
+            const previous = snapshot.config;
+            const names = migratedProfileNames(Object.keys(previous.profiles));
+            const config = { version: '3.0', profiles: Object.create(null),
+                ...(previous.settings ? { settings: { ...previous.settings } } : {}) };
+            const created = [];
+            try {
+                if (previous.version === '1.0') {
+                    for (const [name, profile] of Object.entries(previous.profiles)) {
+                        const stored = await this.createCredential(profile.url, profile.apiKey);
+                        created.push(stored.credentialId);
+                        config.profiles[names.get(name)] = stored;
+                    }
+                }
+                else {
+                    for (const [name, profile] of Object.entries(previous.profiles)) {
+                        let raw = await storeOperation(() => this.store.get(profile.credentialId));
+                        const inCurrentStore = raw !== null;
+                        if (raw === null && this.legacyStore) {
+                            raw = await storeOperation(() => this.legacyStore.get(profile.credentialId));
+                        }
+                        const connection = parseConnection(raw);
+                        if (profile.url !== undefined && normalizeRedmineUrl(profile.url) !== connection.url) {
+                            throw new ConfigurationError('The legacy URL does not match the connection in the system store. Configuration was not changed.');
+                        }
+                        if (inCurrentStore)
+                            config.profiles[names.get(name)] = { credentialId: profile.credentialId };
+                        else {
+                            const stored = await this.createCredential(connection.url, connection.apiKey);
+                            created.push(stored.credentialId);
+                            config.profiles[names.get(name)] = stored;
+                        }
+                    }
+                }
+                config.defaultProfile = (previous.defaultProfile === undefined ? undefined : names.get(previous.defaultProfile)) ??
+                    (Object.hasOwn(config.profiles, 'default') ? 'default' : Object.keys(config.profiles)[0]);
+                writeConfig(this.configPath, config, snapshot.raw);
+            }
+            catch (error) {
+                const warnings = await this.cleanup(created);
+                if (warnings.length)
+                    throw new ConfigurationError(`Migration did not complete; the original file was not replaced. ${warnings.join(' ')}`);
+                throw error;
+            }
+            // Historical-service entries are retained: another local copy may still use them.
+            return { config, warnings: [], profileRenames: [...names].filter(([from, to]) => from !== to).map(([from, to]) => ({ from, to })) };
+        });
+    }
+    async useProfile(name) {
+        validateProfileName(name);
+        await withConfigLock(this.configPath, async () => {
+            const snapshot = readConfig(this.configPath);
+            const config = requireModern(snapshot.config);
+            if (!Object.hasOwn(config.profiles, name))
+                throw new ConfigurationError('Profile not found in this local configuration.');
+            config.defaultProfile = name;
+            writeConfig(this.configPath, config, snapshot.raw);
+        });
+    }
+    async remove(name) {
+        validateProfileName(name);
+        return withConfigLock(this.configPath, async () => {
+            const snapshot = readConfig(this.configPath);
+            const config = requireModern(snapshot.config);
+            if (!Object.hasOwn(config.profiles, name))
+                throw new ConfigurationError('Profile not found in this local configuration.');
+            const id = config.profiles[name].credentialId;
+            delete config.profiles[name];
+            if (config.defaultProfile === name)
+                config.defaultProfile = Object.keys(config.profiles)[0];
+            writeConfig(this.configPath, config, snapshot.raw);
+            return { config, warnings: await this.cleanup([id]) };
+        });
+    }
+}

package/dist/redmine-client.d.ts

@@ -0,0 +1,100 @@
+import { RedmineConfig, RedmineIssue, RedmineProject, RedmineUser, RedmineTimeEntry, RedmineVersion, RedmineNews, RedmineWikiPage, IssueFilterParams, PaginationParams } from './types.js';
+export declare class RedmineClient {
+    private client;
+    constructor(config: RedmineConfig);
+    getIssues(params?: IssueFilterParams): Promise<{
+        issues: RedmineIssue[];
+        total_count: number;
+    }>;
+    getIssue(id: number, include?: string[]): Promise<RedmineIssue>;
+    getProjects(params?: PaginationParams): Promise<{
+        projects: RedmineProject[];
+        total_count: number;
+    }>;
+    getProject(id: string | number, include?: string[]): Promise<RedmineProject>;
+    getUsers(params?: PaginationParams): Promise<{
+        users: RedmineUser[];
+        total_count: number;
+    }>;
+    getUser(id: number, include?: string[]): Promise<RedmineUser>;
+    getCurrentUser(): Promise<RedmineUser>;
+    getTimeEntries(params?: PaginationParams & {
+        project_id?: number;
+        user_id?: number;
+    }): Promise<{
+        time_entries: RedmineTimeEntry[];
+        total_count: number;
+    }>;
+    getTimeEntry(id: number): Promise<RedmineTimeEntry>;
+    getProjectVersions(projectId: string | number): Promise<{
+        versions: RedmineVersion[];
+    }>;
+    getVersion(id: number): Promise<RedmineVersion>;
+    getNews(params?: PaginationParams): Promise<{
+        news: RedmineNews[];
+    }>;
+    getProjectNews(projectId: string | number, params?: PaginationParams): Promise<{
+        news: RedmineNews[];
+    }>;
+    getWikiPages(projectId: string | number): Promise<{
+        wiki_pages: Array<{
+            title: string;
+            version: number;
+            created_on: string;
+            updated_on: string;
+        }>;
+    }>;
+    getWikiPage(projectId: string | number, title: string, version?: number): Promise<{
+        wiki_page: RedmineWikiPage;
+    }>;
+    getProjectMemberships(projectId: string | number, params?: PaginationParams): Promise<any>;
+    getMembership(id: number): Promise<any>;
+    getIssueStatuses(): Promise<{
+        issue_statuses: any[];
+    }>;
+    getTrackers(): Promise<{
+        trackers: any[];
+    }>;
+    getIssuePriorities(): Promise<{
+        issue_priorities: any[];
+    }>;
+    getTimeEntryActivities(): Promise<{
+        time_entry_activities: any[];
+    }>;
+    getRoles(): Promise<{
+        roles: any[];
+    }>;
+    getRole(id: number): Promise<any>;
+    getGroups(params?: PaginationParams): Promise<{
+        groups: any[];
+        total_count: number;
+    }>;
+    getGroup(id: number, include?: string[]): Promise<any>;
+    getCustomFields(): Promise<{
+        custom_fields: any[];
+    }>;
+    search(query: string, params?: {
+        issues?: boolean;
+        news?: boolean;
+        documents?: boolean;
+        changesets?: boolean;
+        wiki_pages?: boolean;
+        messages?: boolean;
+        projects?: boolean;
+    }): Promise<any>;
+    getProjectIssueCategories(projectId: string | number): Promise<{
+        issue_categories: any[];
+    }>;
+    getIssueCategory(id: number): Promise<any>;
+    getAttachment(id: number): Promise<any>;
+    getIssueRelations(issueId: number): Promise<{
+        relations: any[];
+    }>;
+    getRelation(id: number): Promise<any>;
+    getQueries(params?: PaginationParams): Promise<{
+        queries: any[];
+    }>;
+    getProjectFiles(projectId: string | number): Promise<{
+        files: any[];
+    }>;
+}

package/dist/redmine-client.js

@@ -0,0 +1,184 @@
+import { createRedmineHttpClient, positiveInteger } from './http-client.js';
+import { stripApiKeys } from './api-key-filter.js';
+function pathSegment(value) {
+    if (typeof value === 'number')
+        positiveInteger(value, 'id');
+    if (String(value) === '.' || String(value) === '..')
+        throw new Error('Invalid path segment');
+    return encodeURIComponent(String(value));
+}
+export class RedmineClient {
+    client;
+    constructor(config) {
+        this.client = createRedmineHttpClient(config);
+        // Types alone do not remove extra fields from Redmine's JSON responses.
+        this.client.interceptors.response.use(response => {
+            response.data = stripApiKeys(response.data);
+            return response;
+        });
+    }
+    // Issues endpoints
+    async getIssues(params) {
+        const response = await this.client.get('/issues.json', { params });
+        return response.data;
+    }
+    async getIssue(id, include) {
+        const params = include ? { include: include.join(',') } : undefined;
+        const response = await this.client.get(`/issues/${pathSegment(id)}.json`, { params });
+        return response.data.issue;
+    }
+    // Projects endpoints
+    async getProjects(params) {
+        const response = await this.client.get('/projects.json', { params });
+        return response.data;
+    }
+    async getProject(id, include) {
+        const params = include ? { include: include.join(',') } : undefined;
+        const response = await this.client.get(`/projects/${pathSegment(id)}.json`, { params });
+        return response.data.project;
+    }
+    // Users endpoints
+    async getUsers(params) {
+        const response = await this.client.get('/users.json', { params });
+        return response.data;
+    }
+    async getUser(id, include) {
+        const params = include ? { include: include.join(',') } : undefined;
+        const response = await this.client.get(`/users/${pathSegment(id)}.json`, { params });
+        return response.data.user;
+    }
+    async getCurrentUser() {
+        const response = await this.client.get('/users/current.json');
+        return response.data.user;
+    }
+    // Time entries endpoints
+    async getTimeEntries(params) {
+        const response = await this.client.get('/time_entries.json', { params });
+        return response.data;
+    }
+    async getTimeEntry(id) {
+        const response = await this.client.get(`/time_entries/${pathSegment(id)}.json`);
+        return response.data.time_entry;
+    }
+    // Versions endpoints
+    async getProjectVersions(projectId) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/versions.json`);
+        return response.data;
+    }
+    async getVersion(id) {
+        const response = await this.client.get(`/versions/${pathSegment(id)}.json`);
+        return response.data.version;
+    }
+    // News endpoints
+    async getNews(params) {
+        const response = await this.client.get('/news.json', { params });
+        return response.data;
+    }
+    async getProjectNews(projectId, params) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/news.json`, { params });
+        return response.data;
+    }
+    // Wiki endpoints
+    async getWikiPages(projectId) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/wiki/index.json`);
+        return response.data;
+    }
+    async getWikiPage(projectId, title, version) {
+        const url = version
+            ? `/projects/${pathSegment(projectId)}/wiki/${pathSegment(title)}/${pathSegment(version)}.json`
+            : `/projects/${pathSegment(projectId)}/wiki/${pathSegment(title)}.json`;
+        const response = await this.client.get(url);
+        return response.data;
+    }
+    // Memberships endpoints
+    async getProjectMemberships(projectId, params) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/memberships.json`, { params });
+        return response.data;
+    }
+    async getMembership(id) {
+        const response = await this.client.get(`/memberships/${pathSegment(id)}.json`);
+        return response.data.membership;
+    }
+    // Issue statuses, trackers, priorities, etc.
+    async getIssueStatuses() {
+        const response = await this.client.get('/issue_statuses.json');
+        return response.data;
+    }
+    async getTrackers() {
+        const response = await this.client.get('/trackers.json');
+        return response.data;
+    }
+    async getIssuePriorities() {
+        const response = await this.client.get('/enumerations/issue_priorities.json');
+        return response.data;
+    }
+    async getTimeEntryActivities() {
+        const response = await this.client.get('/enumerations/time_entry_activities.json');
+        return response.data;
+    }
+    // Roles and groups
+    async getRoles() {
+        const response = await this.client.get('/roles.json');
+        return response.data;
+    }
+    async getRole(id) {
+        const response = await this.client.get(`/roles/${pathSegment(id)}.json`);
+        return response.data.role;
+    }
+    async getGroups(params) {
+        const response = await this.client.get('/groups.json', { params });
+        return response.data;
+    }
+    async getGroup(id, include) {
+        const params = include ? { include: include.join(',') } : undefined;
+        const response = await this.client.get(`/groups/${pathSegment(id)}.json`, { params });
+        return response.data.group;
+    }
+    // Custom fields
+    async getCustomFields() {
+        const response = await this.client.get('/custom_fields.json');
+        return response.data;
+    }
+    // Search
+    async search(query, params) {
+        const searchParams = {
+            q: query,
+            ...params
+        };
+        const response = await this.client.get('/search.json', { params: searchParams });
+        return response.data;
+    }
+    // Issue categories
+    async getProjectIssueCategories(projectId) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/issue_categories.json`);
+        return response.data;
+    }
+    async getIssueCategory(id) {
+        const response = await this.client.get(`/issue_categories/${pathSegment(id)}.json`);
+        return response.data.issue_category;
+    }
+    // Attachments
+    async getAttachment(id) {
+        const response = await this.client.get(`/attachments/${pathSegment(id)}.json`);
+        return response.data.attachment;
+    }
+    // Issue relations
+    async getIssueRelations(issueId) {
+        const response = await this.client.get(`/issues/${pathSegment(issueId)}/relations.json`);
+        return response.data;
+    }
+    async getRelation(id) {
+        const response = await this.client.get(`/relations/${pathSegment(id)}.json`);
+        return response.data.relation;
+    }
+    // Queries
+    async getQueries(params) {
+        const response = await this.client.get('/queries.json', { params });
+        return response.data;
+    }
+    // Files
+    async getProjectFiles(projectId) {
+        const response = await this.client.get(`/projects/${pathSegment(projectId)}/files.json`);
+        return response.data;
+    }
+}

package/dist/safe-error.d.ts

@@ -0,0 +1,2 @@
+/** Never serialize AxiosError: its config and request contain authentication headers. */
+export declare function safeErrorMessage(error: unknown, secrets?: readonly string[]): string;

package/dist/safe-error.js

@@ -0,0 +1,18 @@
+import axios from 'axios';
+/** Never serialize AxiosError: its config and request contain authentication headers. */
+export function safeErrorMessage(error, secrets = []) {
+    let message;
+    if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const code = error.code && /^[A-Z0-9_]+$/.test(error.code) ? error.code : undefined;
+        message = `HTTP request failed${status ? ` (status ${status})` : ''}${code ? ` [${code}]` : ''}`;
+    }
+    else {
+        message = error instanceof Error ? error.message : 'Unknown error';
+    }
+    for (const secret of secrets) {
+        if (secret)
+            message = message.split(secret).join('[REDACTED]');
+    }
+    return message;
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import type { RedmineConfig } from './types.js';
+export declare function startServer(redmineConfig: RedmineConfig): Promise<void>;