Files
openclaw-backend/mcp/youtrack.js
T

548 lines
21 KiB
JavaScript

#!/usr/bin/env node
/**
* youtrack — MCP-Server fuer die jetbrains/youtrack-Instanz (http://YOUR_SERVER_IP:8089).
*
* Sicherheitsmodell:
* - Feste Basis-URL aus YOUTRACK_URL (kein Host/Port aus Tool-Eingaben -> kein SSRF).
* - Permanent-Token kommt aus einer Datei (YOUTRACK_TOKEN_FILE, uid 1000, Modus 600),
* nie aus dem Config-Text; wird nie geloggt.
* - Suchen und Einzelzugriffe mit expliziten Feldern, um Riesenantworten zu vermeiden;
* Texte auf MAX_CHARS begrenzt, Timeouts hart.
*/
'use strict';
const http = require('http');
const fs = require('fs');
const TIMEOUT_MS = 8000;
const MAX_CHARS = 60000;
const YT_BASE = process.env.YOUTRACK_URL || 'http://YOUR_SERVER_IP:8089';
const INT_NAMES = [...new Set(['Type', 'Priority', 'State', 'Assignee', 'Subsystem', 'Fix versions', 'Affected versions'])];
const DEFAULT_TYPES = {
Type: 'SingleEnumIssueCustomField',
Priority: 'SingleEnumIssueCustomField',
State: 'StateIssueCustomField',
Assignee: 'SingleUserIssueCustomField',
};
function readYoutrackToken() {
const p = process.env.YOUTRACK_TOKEN_FILE;
if (!p) return { error: 'YOUTRACK_TOKEN_FILE ist nicht gesetzt.' };
let st;
try {
st = fs.statSync(p);
} catch (e) {
return { error: `Token-Datei nicht lesbar: ${p}` };
}
if ((st.mode & 0o077) !== 0) return { error: `Token-Datei ist nicht restriktiv berechtigt (Modus ${st.mode & 0o777}).` };
if (st.uid !== 1000) return { error: `Token-Datei gehoert uid ${st.uid}, erwartet 1000.` };
try {
const t = fs.readFileSync(p, 'utf8').trim();
if (!t) return { error: 'Token-Datei ist leer.' };
return { token: t };
} catch (e) {
return { error: 'Token-Datei konnte nicht gelesen werden.' };
}
}
function request(path, token, options) {
return new Promise((resolve) => {
const started = Date.now();
const method = (options && options.method) || 'GET';
const body = options && options.body;
const headers = { Authorization: `Bearer ${token}`, ...(body ? { 'Content-Type': 'application/json' } : {}) };
const req = http.request(YT_BASE + path, { timeout: TIMEOUT_MS, method, headers }, (res) => {
let data = '';
let done = false;
const finish = () => {
if (done) return;
done = true;
let parsed = null;
let parseError = null;
if (data) {
try {
parsed = JSON.parse(data);
} catch (e) {
parseError = 'Antwort ist kein JSON';
}
}
resolve({ code: res.statusCode || 0, ms: Date.now() - started, parsed, parseError, body: data.slice(0, MAX_CHARS) });
};
res.on('data', (d) => {
data += d;
if (data.length > MAX_CHARS * 2) {
res.destroy();
finish();
}
});
res.on('end', finish);
res.on('close', finish);
res.on('error', finish);
});
req.on('timeout', () => {
req.destroy();
resolve({ code: 0, ms: Date.now() - started, parsed: null, parseError: 'timeout' });
});
req.on('error', (e) => resolve({ code: 0, ms: Date.now() - started, parsed: null, parseError: String(e.message || e) }));
if (body) req.write(JSON.stringify(body));
req.end();
});
}
function apiError(r, fallback) {
let desc = fallback;
if (r.parsed && typeof r.parsed === 'object') {
const e = [];
if (r.parsed.error_description || r.parsed.error) e.push(String(r.parsed.error_description || r.parsed.error));
if (r.parsed.error_field) e.push(`Feld: ${r.parsed.error_field}`);
if (e.length) desc = e.join('; ');
}
if (!desc && r.parseError) desc = r.parseError;
return desc;
}
const TOOLS = [
{
name: 'me',
description:
'Identitaet und Eigenschaften des YouTrack-Accounts, mit dem Jarvis zugreift (Login, Name, E-Mail, ob Gast). Lesend.',
inputSchema: { type: 'object', properties: {}, additionalProperties: false },
},
{
name: 'list_projects',
description:
'Listet alle sichtbaren YouTrack-Projekte (Kurzname + Anzeigename). Lesend.',
inputSchema: { type: 'object', properties: {}, additionalProperties: false },
},
{
name: 'search_issues',
description:
'Durchsucht YouTrack mit der nativen Suchsyntax (z.B. "projekt PDEVHDI", "assignee: mich", "Diskuze: tasks", "erstellt: d-7d"). Liefert eine Tabelle mit Kurz-ID, Projekt und (offen/erledigt) und Zusammenfassung.',
inputSchema: {
type: 'object',
properties: {
query: { type: 'string', description: 'YouTrack-Suchabfrage. Leer = alle sichtbaren Issues.' },
max: { type: 'integer', description: 'Maximale Anzahl Treffer (1-50, Standard 10).' },
},
additionalProperties: false,
},
},
{
name: 'get_issue',
description:
'Liefert ein einzelnes YouTrack-Issue mit Zusammenfassung, Beschreibung, Reporter, angepassten Feldern (Typ/Status/Prioritaet/…) und optionalen Kommentaren. Lesend.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Kurz-ID, z.B. PDEVHDI-3.' },
include_comments: { type: 'boolean', description: 'Kommentare mit ausgeben (Standard: false).' },
},
required: ['id'],
additionalProperties: false,
},
},
{
name: 'create_issue',
description:
'Legt ein neues YouTrack-Issue an. Erforderlich: Projekt-Kurzname und Zusammenfassung. Optionale anpassbare Felder als Liste {"name":"Type","value":"Task"} u.ae. (Werte finden sich via get_issue an einem bestehenden Issue des Projekts). Liefert die neue Kurz-ID.',
inputSchema: {
type: 'object',
properties: {
project: { type: 'string', description: 'Projekt-Kurzname, z.B. PDEVHDI.' },
summary: { type: 'string', description: 'Titel des Issues.' },
description: { type: 'string', description: 'Details/Markdown.' },
custom_fields: {
type: 'array',
items: {
type: 'object',
properties: {
name: { type: 'string', description: 'Feldname, z.B. Type, State, Priority, Assignee.' },
value: { description: 'Feldwert: Enum-Name als String oder Objekt (z.B. {"id":"…"}).' },
},
required: ['name', 'value'],
additionalProperties: false,
},
},
},
required: ['project', 'summary'],
additionalProperties: false,
},
},
{
name: 'add_comment',
description:
'Fuegt einem YouTrack-Issue einen Kommentar hinzu (z.B. Monitoring-Erkenntnisse). Liefert Kommentar-IDs/Bestatigung.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Kurz-ID, z.B. PDEVHDI-3.' },
text: { type: 'string', description: 'Kommentartext (Markdown moeglich).' },
},
required: ['id', 'text'],
additionalProperties: false,
},
},
{
name: 'update_issue_fields',
description:
'Aendert anpassbare Felder eines bestehenden YouTrack-Issues, z.B. State auf "Solved" (Status/State Bundle), Assignee, Priority. Liefert den neuen Feldzustand.',
inputSchema: {
type: 'object',
properties: {
id: { type: 'string', description: 'Kurz-ID, z.B. PDEVHDI-3.' },
custom_fields: {
type: 'array',
items: {
type: 'object',
properties: {
name: { type: 'string', description: 'Feldname, z.B. State, Assignee, Priority.' },
value: { description: 'Feldwert: Enum-Name als String oder Objekt.' },
},
required: ['name', 'value'],
additionalProperties: false,
},
},
},
required: ['id', 'custom_fields'],
additionalProperties: false,
},
},
];
function fmtValue(v) {
if (v === null || v === undefined) return '-';
if (typeof v === 'boolean') return v ? 'ja' : 'nein';
if (typeof v === 'object') {
if (v.name) return String(v.name);
if (v.login) return String(v.login);
if (v.seconds !== undefined) return Math.round(v.seconds / 3600) + ' h';
try {
return JSON.stringify(v);
} catch (e) {
return '?';
}
}
return String(v);
}
async function me() {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const r = await request('/api/users/me?fields=id,name,login,email,guest,$type', auth.token);
if (r.code !== 200 || !r.parsed) return { error: true, text: `Identitaet nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` };
const u = r.parsed;
const lines = [
'## YouTrack-Account',
'',
`- Login: **${u.login || '?'}**`,
`- Name: ${u.name || '-'}`,
`- E-Mail: ${u.email || '-'}`,
`- Gast: ${u.guest ? 'ja' : 'nein'}`,
`- ID: ${u.id || '-'}`,
];
return { error: false, text: lines.join('\n') };
}
async function listProjects() {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const r = await request('/api/admin/projects?fields=shortName,name,description', auth.token);
if (r.code === 403) return { error: true, text: 'Projektliste nicht sichtbar (403) fuer diesen Account.' };
if (r.code !== 200 || !Array.isArray(r.parsed)) {
return { error: true, text: `Projektliste nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` };
}
const lines = ['## YouTrack-Projekte', '', '| Kurzname | Name |', '|---|---|'];
for (const p of r.parsed) lines.push(`| ${p.shortName} | ${p.name || ''} |`);
return { error: false, text: lines.join('\n') };
}
async function searchIssues(args) {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const q = String((args && args.query) || '').trim();
const max = Math.min(50, Math.max(1, Number((args && args.max) || 10)));
const query = q ? `query=${encodeURIComponent(q)}&` : 'query=&';
const r = await request(
`/api/issues?${query}$top=${max}&fields=idReadable,summary,resolved,created,project(shortName,name)`,
auth.token
);
if (r.code !== 200 || !Array.isArray(r.parsed)) {
return { error: true, text: `Suche fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` };
}
const lines = [
'## YouTrack-Issues',
'',
`Suche: \`${q || '(alle)'}\` — ${r.parsed.length} Treffer`,
'',
'| ID | Projekt | Zustand | Zusammenfassung |',
'|---|---|---|---|',
];
for (const i of r.parsed) {
const state = i.resolved ? 'erledigt' : 'offen';
const proj = (i.project && i.project.shortName) || '-';
lines.push(`| ${i.idReadable || i.id} | ${proj} | ${state} | ${String(i.summary || '').slice(0, 90)} |`);
}
return { error: false, text: lines.join('\n') };
}
async function getIssue(args) {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const id = String((args && args.id) || '').trim();
if (!/^[A-Z0-9]+-\d+$/i.test(id)) return { error: true, text: `Ungueltige Kurz-ID "${id}".` };
const withComments = !!(args && args.include_comments);
const fields = [
'idReadable',
'summary',
'description',
'created',
'updated',
'resolved',
'reporter(login,name)',
'project(shortName,name)',
'customFields(id,name,$type,value(name,login))',
];
if (withComments) fields.push('comments(id,text,created,author(login,name))');
const r = await request(`/api/issues/${encodeURIComponent(id)}?fields=${encodeURIComponent(fields.join(','))}`, auth.token);
if (r.code !== 200 || !r.parsed) {
return { error: true, text: `Issue ${id} nicht lesbar: HTTP ${r.code} (${apiError(r, '')})` };
}
const i = r.parsed;
const lines = [
`## ${i.idReadable || id} — ${i.summary || '(ohne Zusammenfassung)'}`,
'',
`- Projekt: ${(i.project && (i.project.shortName + ' ' + (i.project.name || ''))) || '-'}`,
`- Reporter: ${(i.reporter && (i.reporter.login || i.reporter.name)) || '-'}`,
`- Erstellt: ${i.created ? new Date(i.created).toISOString().replace('T', ' ').slice(0, 16) + 'U' : '-'}`,
i.updated ? `- Geaendert: ${new Date(i.updated).toISOString().replace('T', ' ').slice(0, 16) + 'U'}` : null,
`- Status: **${i.resolved ? 'erledigt' : 'offen'}**`,
'',
'### Angepasste Felder',
].filter((l) => l !== null);
const cfs = Array.isArray(i.customFields) ? i.customFields : [];
if (cfs.length) {
lines.push('', '| Feld | Wert |', '|---|---|');
for (const cf of cfs) lines.push(`| ${cf.name} | ${fmtValue(cf.value)} |`);
} else {
lines.push('', '(keine)');
}
lines.push('', '### Beschreibung');
lines.push(String(i.description || '*(leer)*').slice(0, MAX_CHARS / 2));
if (withComments) {
lines.push('', `### Kommentare (${Array.isArray(i.comments) ? i.comments.length : 0})`);
const cs = Array.isArray(i.comments) ? i.comments : [];
for (const c of cs.slice(0, 30)) {
const who = (c.author && (c.author.login || c.author.name)) || '?';
const when = c.created ? new Date(c.created).toISOString().replace('T', ' ').slice(0, 16) + 'U' : '?';
lines.push(`- **${who}** (${when}): ${String(c.text || '').slice(0, 600)}`);
}
}
return { error: false, text: lines.join('\n') };
}
async function resolveTypesFor(project, token) {
const r = await request(
`/api/issues?query=${encodeURIComponent(`project: ${project}`)}&$top=1&fields=customFields(id,name,$type)`,
token
);
const map = {};
if (r.code === 200 && Array.isArray(r.parsed) && r.parsed.length) {
for (const cf of r.parsed[0].customFields || []) if (cf.name && cf.$type) map[cf.name] = cf.$type;
}
return map;
}
function normaliseCustomFields(fields, types) {
return (fields || []).map((f) => {
const name = String(f.name || '').trim();
let value = f.value;
if (value !== null && typeof value === 'object' && !value.name && !value.id) {
throw new Error(`Feld "${name}": Wert muss ein String (Enum-Name) oder Objekt mit id/name sein.`);
}
if (typeof value === 'string') value = { name: value };
return {
name,
$type: (types && types[name]) || DEFAULT_TYPES[name] || 'SingleEnumIssueCustomField',
value,
};
});
}
async function createIssue(args) {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const project = String((args && args.project) || '').trim();
const summary = String((args && args.summary) || '').trim();
if (!project) return { error: true, text: 'Projekt-Kurzname fehlt.' };
if (!summary) return { error: true, text: 'Zusammenfassung fehlt.' };
const types = await resolveTypesFor(project, auth.token);
const body = { project: { shortName: project }, summary };
if (args && args.description) body.description = String(args.description);
if (args && args.custom_fields && args.custom_fields.length) {
try {
body.customFields = normaliseCustomFields(args.custom_fields, types);
} catch (e) {
return { error: true, text: e.message };
}
}
const r = await request(`/api/issues?fields=idReadable,summary,created,customFields(id,name,$type,value(name))`, auth.token, {
method: 'POST',
body,
});
if (r.code !== 200 || !r.parsed || !r.parsed.idReadable) {
return { error: true, text: `Anlegen fehlgeschlagen: HTTP ${r.code} (${apiError(r, 'Pflichtfelder evtl. unvollstaendig')})` };
}
const lines = [
`## Issue angelegt: ${r.parsed.idReadable}`,
'',
`- Zusammenfassung: ${r.parsed.summary}`,
];
for (const cf of r.parsed.customFields || []) lines.push(`- ${cf.name}: ${fmtValue(cf.value)}`);
lines.push('', `Tipp: Details liest du mit get_issue (id=${r.parsed.idReadable}).`);
return { error: false, text: lines.join('\n') };
}
async function addComment(args) {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const id = String((args && args.id) || '').trim();
const text = String((args && args.text) || '').trim();
if (!/^[A-Z0-9]+-\d+$/i.test(id)) return { error: true, text: `Ungueltige Kurz-ID "${id}".` };
if (!text) return { error: true, text: 'Kommentartext fehlt.' };
const r = await request(`/api/issues/${encodeURIComponent(id)}/comments?fields=id,text,author(login)`, auth.token, {
method: 'POST',
body: { text },
});
if (r.code !== 200 || !r.parsed) {
return { error: true, text: `Kommentar fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` };
}
return {
error: false,
text: `Kommentar zu ${id} hinzugefuegt (von ${r.parsed.author ? r.parsed.author.login : '?'}).`,
};
}
async function updateFields(args) {
const auth = readYoutrackToken();
if (auth.error) return { error: true, text: `Token nicht verfuegbar: ${auth.error}` };
const id = String((args && args.id) || '').trim();
if (!/^[A-Z0-9]+-\d+$/i.test(id)) return { error: true, text: `Ungueltige Kurz-ID "${id}".` };
const f = (args && args.custom_fields) || [];
if (!Array.isArray(f) || !f.length) return { error: true, text: 'Keine Felder angegeben.' };
const cur = await request(
`/api/issues/${encodeURIComponent(id)}?fields=customFields(id,name,$type)`,
auth.token
);
const types = {};
if (cur.code === 200 && cur.parsed && Array.isArray(cur.parsed.customFields)) {
for (const cf of cur.parsed.customFields) if (cf.name && cf.$type) types[cf.name] = cf.$type;
}
let customFields;
try {
customFields = normaliseCustomFields(f, types);
} catch (e) {
return { error: true, text: e.message };
}
const r = await request(
`/api/issues/${encodeURIComponent(id)}?fields=idReadable,customFields(name,value(name,login))`,
auth.token,
{ method: 'POST', body: { customFields } }
);
if (r.code !== 200 || !r.parsed) {
return { error: true, text: `Aendern fehlgeschlagen: HTTP ${r.code} (${apiError(r, '')})` };
}
const lines = ['## Felder aktualisiert', '', `- Issue: ${r.parsed.idReadable || id}`, '', '| Feld | Wert |', '|---|---|'];
for (const cf of r.parsed.customFields || []) lines.push(`| ${cf.name} | ${fmtValue(cf.value)} |`);
return { error: false, text: lines.join('\n') };
}
function reply(id, result) {
process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
}
function replyError(id, code, message) {
process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
}
let buf = '';
process.stdin.setEncoding('utf8');
process.stdin.on('data', (chunk) => {
buf += chunk;
let idx;
while ((idx = buf.indexOf('\n')) >= 0) {
const line = buf.slice(0, idx).trim();
buf = buf.slice(idx + 1);
if (!line) continue;
handle(line);
}
});
function toolAnnotations(name) {
const read = !['create_issue', 'add_comment', 'update_issue_fields'].includes(name);
return {
title: name.replace(/_/g, ' '),
readOnlyHint: read,
destructiveHint: false,
idempotentHint: read,
openWorldHint: true,
};
}
function handle(line) {
let msg;
try {
msg = JSON.parse(line);
} catch (e) {
process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) + '\n');
return;
}
const { id, method, params } = msg;
if (method === 'notifications/initialized' || (id === undefined && method)) return;
if (method === 'initialize') {
reply(id, {
protocolVersion: (params && params.protocolVersion) || '2024-11-05',
capabilities: { tools: {} },
serverInfo: { name: 'youtrack', version: '1.0.0' },
});
return;
}
if (method === 'ping') {
reply(id, {});
return;
}
if (method === 'tools/list') {
reply(id, {
tools: TOOLS.map(({ name, description, inputSchema }) => ({
name,
description,
inputSchema,
annotations: toolAnnotations(name),
})),
});
return;
}
if (method === 'tools/call') {
const name = params && params.name;
const args = (params && params.arguments) || {};
const dispatch = {
me: [false, () => me()],
list_projects: [false, () => listProjects()],
search_issues: [false, () => searchIssues(args)],
get_issue: [false, () => getIssue(args)],
create_issue: [false, () => createIssue(args)],
add_comment: [false, () => addComment(args)],
update_issue_fields: [false, () => updateFields(args)],
};
const entry = dispatch[name];
if (!entry) {
reply(id, { content: [{ type: 'text', text: `Unbekanntes Werkzeug: ${name}` }], isError: true });
return;
}
entry[1]()
.then((r) => reply(id, { content: [{ type: 'text', text: r.text }], isError: Boolean(r.error) }))
.catch((e) => reply(id, { content: [{ type: 'text', text: `Interner Fehler: ${e.message || e}` }], isError: true }));
return;
}
replyError(id, -32601, 'Method not found');
}