issues-mcp 1.0.0

package/dist/chunk-Y53ZARWV.js

@@ -0,0 +1,1671 @@
+// src/config.ts
+var ENV_SPECS = [
+  {
+    kind: "jira",
+    required: ["JIRA_BASE_URL", "JIRA_API_TOKEN", "JIRA_ACCOUNT_EMAIL"],
+    secretVars: ["JIRA_API_TOKEN"],
+    build: (env) => ({
+      baseUrl: env.JIRA_BASE_URL ?? "",
+      credentials: {
+        type: "apiKey",
+        apiKey: env.JIRA_API_TOKEN ?? "",
+        accountId: env.JIRA_ACCOUNT_EMAIL ?? ""
+      }
+    })
+  },
+  {
+    kind: "redmine",
+    required: ["REDMINE_BASE_URL", "REDMINE_API_KEY"],
+    secretVars: ["REDMINE_API_KEY"],
+    build: (env) => ({
+      baseUrl: env.REDMINE_BASE_URL ?? "",
+      credentials: { type: "apiKey", apiKey: env.REDMINE_API_KEY ?? "" }
+    })
+  }
+];
+function loadConfig(env = process.env) {
+  const trackers = [];
+  const secrets = [];
+  const warnings = [];
+  for (const spec of ENV_SPECS) {
+    const present = spec.required.filter((name) => hasValue(env[name]));
+    if (present.length === 0) continue;
+    if (present.length < spec.required.length) {
+      const missing = spec.required.filter((name) => !hasValue(env[name]));
+      warnings.push(`${spec.kind}: skipped \u2014 missing required env var(s): ${missing.join(", ")}`);
+      continue;
+    }
+    trackers.push({ kind: spec.kind, connection: spec.build(env) });
+    for (const name of spec.secretVars) {
+      const value = env[name];
+      if (hasValue(value)) secrets.push(value);
+    }
+  }
+  return { trackers, secrets, warnings };
+}
+function hasValue(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function makeRedactor(secrets) {
+  const real = [...new Set(secrets)].filter((s) => s.length > 0);
+  real.sort((a, b) => b.length - a.length);
+  return (text) => real.reduce((acc, s) => acc.split(s).join("***"), text);
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../core/dist/errors.js
+var IssueTrackerError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var NotFoundError = class extends IssueTrackerError {
+};
+var AuthError = class extends IssueTrackerError {
+};
+var ValidationError = class extends IssueTrackerError {
+  fields;
+  constructor(message, options) {
+    super(message, options);
+    this.fields = options?.fields;
+  }
+};
+var RateLimitError = class extends IssueTrackerError {
+  retryAfterSeconds;
+  constructor(message, options) {
+    super(message, options);
+    this.retryAfterSeconds = options?.retryAfterSeconds;
+  }
+};
+var NotSupportedError = class extends IssueTrackerError {
+};
+
+// ../jira/dist/client.js
+var JiraClient = class {
+  baseUrl;
+  authHeader;
+  constructor(config) {
+    const { credentials } = config;
+    if (credentials.accountId === void 0 || credentials.accountId === "") {
+      throw new AuthError("Jira requires credentials.accountId (the account email) for Basic auth.");
+    }
+    const token = `${credentials.accountId}:${credentials.apiKey}`;
+    this.authHeader = `Basic ${Buffer.from(token).toString("base64")}`;
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+  }
+  // Perform a request against `/rest/api/3{path}` and return the parsed JSON
+  // body, or undefined for empty (204) responses.
+  async request(path, options = {}) {
+    const url = new URL(`${this.baseUrl}/rest/api/3${path}`);
+    if (options.query !== void 0) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      Authorization: this.authHeader,
+      Accept: "application/json"
+    };
+    const init = {
+      method: options.method ?? "GET",
+      headers,
+      signal: options.signal
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(url, init);
+    } catch (cause) {
+      throw new IssueTrackerError(`Network error calling Jira: ${String(cause)}`, { cause });
+    }
+    if (!response.ok) {
+      await this.throwForStatus(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (text === "") {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  // Map a non-2xx response onto the typed error hierarchy. Always throws.
+  async throwForStatus(response) {
+    const status = response.status;
+    const raw = await response.text().catch(() => "");
+    let parsed;
+    try {
+      parsed = raw === "" ? void 0 : JSON.parse(raw);
+    } catch {
+      parsed = void 0;
+    }
+    const messages = parsed?.errorMessages ?? [];
+    const fields = parsed?.errors;
+    const summary = messages.length > 0 ? messages.join("; ") : fields !== void 0 ? Object.entries(fields).map(([k, v]) => `${k}: ${v}`).join("; ") : raw.slice(0, 500);
+    switch (status) {
+      case 401:
+        throw new AuthError(`Jira authentication failed (401): ${summary}`);
+      case 403:
+        throw new AuthError(`Jira authorization failed (403): ${summary}`);
+      case 404:
+        throw new NotFoundError(`Jira resource not found (404): ${summary}`);
+      case 400:
+      case 422:
+        throw new ValidationError(`Jira rejected the request (${status}): ${summary}`, {
+          fields
+        });
+      case 429: {
+        const retryHeader = response.headers.get("Retry-After");
+        const retryAfterSeconds = retryHeader !== null && retryHeader !== "" ? Number(retryHeader) : void 0;
+        throw new RateLimitError(`Jira is throttling requests (429): ${summary}`, {
+          retryAfterSeconds: Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : void 0
+        });
+      }
+      default:
+        throw new IssueTrackerError(`Jira request failed (${status}): ${summary}`);
+    }
+  }
+};
+
+// ../jira/dist/adf.js
+function adfToText(node) {
+  if (node === null || node === void 0) {
+    return null;
+  }
+  return flatten(node).replace(/\n{3,}/g, "\n\n").trim();
+}
+var BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading",
+  "blockquote",
+  "listItem",
+  "bulletList",
+  "orderedList",
+  "codeBlock",
+  "rule"
+]);
+function flatten(node) {
+  if (node.type === "text") {
+    return node.text ?? "";
+  }
+  if (node.type === "hardBreak") {
+    return "\n";
+  }
+  const children = node.content ?? [];
+  const inner = children.map(flatten).join("");
+  if (node.type !== void 0 && BLOCK_TYPES.has(node.type)) {
+    return `${inner}
+`;
+  }
+  return inner;
+}
+function textToAdf(text) {
+  return {
+    type: "doc",
+    version: 1,
+    content: [
+      {
+        type: "paragraph",
+        content: [{ type: "text", text }]
+      }
+    ]
+  };
+}
+
+// ../jira/dist/mappers.js
+function mapUser(raw) {
+  const user2 = {
+    id: raw.accountId,
+    name: raw.displayName ?? raw.accountId
+  };
+  if (raw.emailAddress !== void 0) {
+    user2.email = raw.emailAddress;
+  }
+  return user2;
+}
+function mapStatusCategory(key) {
+  switch (key) {
+    case "new":
+      return "open";
+    case "indeterminate":
+      return "in_progress";
+    case "done":
+      return "done";
+    default:
+      return "unknown";
+  }
+}
+function mapStatus(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    category: mapStatusCategory(raw.statusCategory?.key)
+  };
+}
+function mapComment(raw) {
+  const item = {
+    kind: "comment",
+    id: raw.id,
+    author: raw.author !== void 0 ? mapUser(raw.author) : { id: "unknown", name: "Unknown" },
+    body: adfToText(raw.body) ?? "",
+    createdAt: raw.created
+  };
+  if (raw.updated !== void 0) {
+    item.updatedAt = raw.updated;
+  }
+  return item;
+}
+function mapChangelogHistory(raw) {
+  return {
+    kind: "change",
+    id: raw.id,
+    author: raw.author !== void 0 ? mapUser(raw.author) : { id: "unknown", name: "Unknown" },
+    createdAt: raw.created,
+    changes: (raw.items ?? []).map((item) => ({
+      field: item.field ?? "",
+      from: item.fromString ?? null,
+      to: item.toString ?? null
+    }))
+  };
+}
+function mapIssue(raw) {
+  const fields = raw.fields;
+  const items = [];
+  for (const history of raw.changelog?.histories ?? []) {
+    items.push(mapChangelogHistory(history));
+  }
+  for (const comment of fields.comment?.comments ?? []) {
+    items.push(mapComment(comment));
+  }
+  const status = fields.status !== void 0 ? mapStatus(fields.status) : { id: "unknown", name: "Unknown", category: "unknown" };
+  const issue = {
+    id: raw.id,
+    key: raw.key,
+    title: fields.summary ?? "",
+    description: adfToText(fields.description),
+    status,
+    author: fields.reporter !== void 0 && fields.reporter !== null ? mapUser(fields.reporter) : null,
+    assignee: fields.assignee !== void 0 && fields.assignee !== null ? mapUser(fields.assignee) : null,
+    attributes: {},
+    items,
+    createdAt: fields.created,
+    updatedAt: fields.updated
+  };
+  if (fields.project !== void 0) {
+    issue.projectId = fields.project.id;
+  }
+  return issue;
+}
+function mapTransition(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    to: raw.to !== void 0 ? mapStatus(raw.to) : { id: "unknown", name: "Unknown", category: "unknown" }
+  };
+}
+function mapWorklog(raw, issueId) {
+  const entry = {
+    id: `${issueId}/${raw.id}`,
+    issueId,
+    user: raw.author !== void 0 ? mapUser(raw.author) : { id: "unknown", name: "Unknown" },
+    date: raw.started,
+    durationMinutes: Math.round(raw.timeSpentSeconds / 60),
+    createdAt: raw.created,
+    updatedAt: raw.updated
+  };
+  const description = adfToText(raw.comment);
+  if (description !== null) {
+    entry.description = description;
+  }
+  return entry;
+}
+function attributeToJiraValue(attr) {
+  switch (attr.type) {
+    case "string":
+    case "text":
+    case "number":
+    case "date":
+    case "boolean":
+      return attr.value;
+    case "enum":
+      return { id: attr.value.id };
+    case "multi_enum":
+      return attr.value.map((option) => ({ id: option.id }));
+    case "user":
+      return { accountId: attr.value.id };
+  }
+}
+
+// ../jira/dist/jql.js
+function jqlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function statusCategoryToJql(category) {
+  switch (category) {
+    case "open":
+      return "To Do";
+    case "in_progress":
+      return "In Progress";
+    case "done":
+      return "Done";
+    default:
+      return void 0;
+  }
+}
+function buildJql(filter) {
+  const clauses = [];
+  if (filter.text !== void 0 && filter.text !== "") {
+    clauses.push(`text ~ ${jqlString(filter.text)}`);
+  }
+  if (filter.projectId !== void 0) {
+    clauses.push(`project = ${jqlString(filter.projectId)}`);
+  }
+  if (filter.assigneeId !== void 0) {
+    clauses.push(`assignee = ${jqlString(filter.assigneeId)}`);
+  }
+  if (filter.authorId !== void 0) {
+    clauses.push(`reporter = ${jqlString(filter.authorId)}`);
+  }
+  if (filter.statusCategory !== void 0) {
+    const mapped = statusCategoryToJql(filter.statusCategory);
+    if (mapped !== void 0) {
+      clauses.push(`statusCategory = ${jqlString(mapped)}`);
+    }
+  }
+  if (filter.createdAfter !== void 0) {
+    clauses.push(`created >= ${jqlString(filter.createdAfter)}`);
+  }
+  if (filter.createdBefore !== void 0) {
+    clauses.push(`created <= ${jqlString(filter.createdBefore)}`);
+  }
+  if (filter.updatedAfter !== void 0) {
+    clauses.push(`updated >= ${jqlString(filter.updatedAfter)}`);
+  }
+  if (filter.updatedBefore !== void 0) {
+    clauses.push(`updated <= ${jqlString(filter.updatedBefore)}`);
+  }
+  let jql = clauses.join(" AND ");
+  if (filter.sort !== void 0) {
+    const dir = filter.sort.dir === "desc" ? "DESC" : "ASC";
+    jql = `${jql}${jql === "" ? "" : " "}ORDER BY ${filter.sort.field} ${dir}`;
+  }
+  return jql;
+}
+
+// ../jira/dist/issuesTracker.js
+var ISSUE_FIELDS = [
+  "summary",
+  "description",
+  "status",
+  "reporter",
+  "assignee",
+  "project",
+  "created",
+  "updated"
+];
+function buildFieldsPayload(input) {
+  const fields = {};
+  if (input.title !== void 0) {
+    fields.summary = input.title;
+  }
+  if (input.description !== void 0) {
+    fields.description = input.description === null ? null : textToAdf(input.description);
+  }
+  if (input.projectId !== void 0) {
+    fields.project = { key: input.projectId };
+  }
+  if (input.assigneeId !== void 0) {
+    fields.assignee = input.assigneeId === null ? null : { accountId: input.assigneeId };
+  }
+  if (input.attributes !== void 0) {
+    for (const [key, attr] of Object.entries(input.attributes)) {
+      const value = attr;
+      if (key === "issuetype") {
+        fields.issuetype = value.type === "enum" ? { id: value.value.id } : attributeToJiraValue(value);
+      } else {
+        fields[key] = attributeToJiraValue(value);
+      }
+    }
+  }
+  return fields;
+}
+var JiraIssuesTracker = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async capabilities() {
+    const fields = [
+      {
+        id: "project",
+        name: "Project",
+        type: "enum",
+        required: true,
+        readOnly: false,
+        allowedValues: await this.fetchProjects()
+      },
+      {
+        id: "issuetype",
+        name: "Issue Type",
+        type: "enum",
+        required: true,
+        readOnly: false,
+        allowedValues: await this.fetchIssueTypes()
+      },
+      { id: "summary", name: "Summary", type: "string", required: true, readOnly: false },
+      { id: "description", name: "Description", type: "text", required: false, readOnly: false }
+    ];
+    return {
+      canCreate: true,
+      canUpdate: true,
+      canDelete: true,
+      canComment: true,
+      canTransition: true,
+      fields
+    };
+  }
+  async fetchProjects() {
+    const res = await this.client.request("/project/search", {
+      query: { maxResults: 100 }
+    });
+    return (res.values ?? []).map((project) => ({
+      id: project.id,
+      name: project.name ?? project.key ?? project.id
+    }));
+  }
+  async fetchIssueTypes() {
+    const res = await this.client.request("/issuetype");
+    return res.map((type) => ({ id: type.id, name: type.name }));
+  }
+  async search(filter) {
+    const body = {
+      jql: buildJql(filter),
+      fields: ISSUE_FIELDS
+    };
+    if (filter.limit !== void 0) {
+      body.maxResults = filter.limit;
+    }
+    if (filter.cursor !== void 0) {
+      body.nextPageToken = filter.cursor;
+    }
+    const res = await this.client.request("/search/jql", {
+      method: "POST",
+      body
+    });
+    const page = {
+      items: (res.issues ?? []).map(mapIssue)
+    };
+    if (res.nextPageToken !== void 0 && res.isLast !== true) {
+      page.nextCursor = res.nextPageToken;
+    }
+    return page;
+  }
+  async get(id) {
+    const raw = await this.client.request(`/issue/${encodeURIComponent(id)}`, {
+      query: { expand: "changelog" }
+    });
+    const issue = mapIssue(raw);
+    const comments = await this.client.request(`/issue/${encodeURIComponent(id)}/comment`);
+    const commentItems = (comments.comments ?? []).map(mapComment);
+    issue.items = [...issue.items, ...commentItems];
+    return issue;
+  }
+  async create(input) {
+    const fields = buildFieldsPayload(input);
+    const created = await this.client.request("/issue", {
+      method: "POST",
+      body: { fields }
+    });
+    const idOrKey = created.key ?? created.id;
+    if (idOrKey === void 0) {
+      throw new ValidationError("Jira did not return an id or key for the created issue.");
+    }
+    return this.get(idOrKey);
+  }
+  async update(id, input) {
+    const fields = buildFieldsPayload(input);
+    await this.client.request(`/issue/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      body: { fields }
+    });
+    return this.get(id);
+  }
+  async delete(id) {
+    await this.client.request(`/issue/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+  async addComment(issueId, body) {
+    const created = await this.client.request(`/issue/${encodeURIComponent(issueId)}/comment`, {
+      method: "POST",
+      body: { body: textToAdf(body) }
+    });
+    return mapComment(created);
+  }
+  async getTransitions(issueId) {
+    const res = await this.client.request(`/issue/${encodeURIComponent(issueId)}/transitions`);
+    return (res.transitions ?? []).map(mapTransition);
+  }
+  async transition(issueId, transitionId) {
+    await this.client.request(`/issue/${encodeURIComponent(issueId)}/transitions`, {
+      method: "POST",
+      body: { transition: { id: transitionId } }
+    });
+    return this.get(issueId);
+  }
+};
+
+// ../jira/dist/timeTracker.js
+function parseWorklogId(id) {
+  const slash = id.indexOf("/");
+  if (slash === -1) {
+    throw new ValidationError(`Invalid worklog id "${id}". Expected the format "<issueId>/<worklogId>".`);
+  }
+  return { issueId: id.slice(0, slash), worklogId: id.slice(slash + 1) };
+}
+function toJiraStarted(isoDate) {
+  const date = new Date(isoDate);
+  if (Number.isNaN(date.getTime())) {
+    throw new ValidationError(`Invalid date "${isoDate}" for worklog.`);
+  }
+  const iso = date.toISOString();
+  return iso.replace("Z", "+0000");
+}
+var JiraTimeTracker = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  capabilities() {
+    return Promise.resolve({
+      canCreate: true,
+      canUpdate: true,
+      canDelete: true,
+      requiresIssue: true,
+      activities: []
+    });
+  }
+  async search(filter) {
+    if (filter.issueId === void 0) {
+      throw new NotSupportedError("Jira core worklogs are scoped per issue; set filter.issueId to search worklogs.");
+    }
+    const res = await this.client.request(`/issue/${encodeURIComponent(filter.issueId)}/worklog`);
+    let entries = (res.worklogs ?? []).map((worklog) => mapWorklog(worklog, filter.issueId));
+    if (filter.userId !== void 0) {
+      entries = entries.filter((entry) => entry.user.id === filter.userId);
+    }
+    if (filter.from !== void 0) {
+      const from = new Date(filter.from).getTime();
+      entries = entries.filter((entry) => new Date(entry.date).getTime() >= from);
+    }
+    if (filter.to !== void 0) {
+      const to = new Date(filter.to).getTime();
+      entries = entries.filter((entry) => new Date(entry.date).getTime() <= to);
+    }
+    return { items: entries };
+  }
+  async get(id) {
+    const { issueId, worklogId } = parseWorklogId(id);
+    const raw = await this.client.request(`/issue/${encodeURIComponent(issueId)}/worklog/${encodeURIComponent(worklogId)}`);
+    return mapWorklog(raw, issueId);
+  }
+  async create(input) {
+    const body = {
+      started: toJiraStarted(input.date),
+      timeSpentSeconds: input.durationMinutes * 60
+    };
+    if (input.description !== void 0) {
+      body.comment = textToAdf(input.description);
+    }
+    const raw = await this.client.request(`/issue/${encodeURIComponent(input.issueId)}/worklog`, { method: "POST", body });
+    return mapWorklog(raw, input.issueId);
+  }
+  async update(id, input) {
+    const { issueId, worklogId } = parseWorklogId(id);
+    const body = {};
+    if (input.date !== void 0) {
+      body.started = toJiraStarted(input.date);
+    }
+    if (input.durationMinutes !== void 0) {
+      body.timeSpentSeconds = input.durationMinutes * 60;
+    }
+    if (input.description !== void 0) {
+      body.comment = textToAdf(input.description);
+    }
+    const raw = await this.client.request(`/issue/${encodeURIComponent(issueId)}/worklog/${encodeURIComponent(worklogId)}`, { method: "PUT", body });
+    return mapWorklog(raw, issueId);
+  }
+  async delete(id) {
+    const { issueId, worklogId } = parseWorklogId(id);
+    await this.client.request(`/issue/${encodeURIComponent(issueId)}/worklog/${encodeURIComponent(worklogId)}`, { method: "DELETE" });
+  }
+};
+
+// ../jira/dist/session.js
+var JiraSession = class {
+  tracker;
+  user;
+  constructor(tracker, user2) {
+    this.tracker = tracker;
+    this.user = user2;
+  }
+  currentUser() {
+    return Promise.resolve(this.user);
+  }
+  close() {
+    return Promise.resolve();
+  }
+};
+var JiraAuthenticator = class {
+  async authenticate(config) {
+    const client = new JiraClient(config);
+    let me;
+    try {
+      me = await client.request("/myself");
+    } catch (cause) {
+      if (cause instanceof AuthError) {
+        throw cause;
+      }
+      throw new AuthError(`Failed to validate Jira credentials: ${String(cause)}`, { cause });
+    }
+    const tracker = {
+      issues: new JiraIssuesTracker(client),
+      time: new JiraTimeTracker(client)
+    };
+    return new JiraSession(tracker, mapUser(me));
+  }
+};
+
+// ../redmine/dist/client.js
+var RedmineClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.credentials.apiKey;
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+  }
+  // Perform a request against `{baseUrl}{path}` and return the parsed JSON body,
+  // or undefined for empty (204) responses.
+  async request(path, options = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (options.query !== void 0) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value === void 0) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          for (const entry of value) {
+            url.searchParams.append(key, entry);
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {
+      "X-Redmine-API-Key": this.apiKey,
+      Accept: "application/json"
+    };
+    const init = {
+      method: options.method ?? "GET",
+      headers,
+      signal: options.signal
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(url, init);
+    } catch (cause) {
+      throw new IssueTrackerError(`Network error calling Redmine: ${String(cause)}`, { cause });
+    }
+    if (!response.ok) {
+      await this.throwForStatus(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (text === "") {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  // Map a non-2xx response onto the typed error hierarchy. Always throws.
+  async throwForStatus(response) {
+    const status = response.status;
+    const raw = await response.text().catch(() => "");
+    let parsed;
+    try {
+      parsed = raw === "" ? void 0 : JSON.parse(raw);
+    } catch {
+      parsed = void 0;
+    }
+    const messages = parsed?.errors ?? [];
+    const summary = messages.length > 0 ? messages.join("; ") : raw.slice(0, 500);
+    switch (status) {
+      case 401:
+        throw new AuthError(`Redmine authentication failed (401): ${summary}`);
+      case 403:
+        throw new AuthError(`Redmine authorization failed (403): ${summary}`);
+      case 404:
+        throw new NotFoundError(`Redmine resource not found (404): ${summary}`);
+      case 422:
+        throw new ValidationError(`Redmine rejected the request (422): ${summary}`);
+      case 429: {
+        const retryHeader = response.headers.get("Retry-After");
+        const retryAfterSeconds = retryHeader !== null && retryHeader !== "" ? Number(retryHeader) : void 0;
+        throw new RateLimitError(`Redmine is throttling requests (429): ${summary}`, {
+          retryAfterSeconds: retryAfterSeconds !== void 0 && Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : void 0
+        });
+      }
+      default:
+        throw new IssueTrackerError(`Redmine request failed (${status}): ${summary}`);
+    }
+  }
+};
+
+// ../redmine/dist/mappers.js
+function mapCurrentUser(user2) {
+  const name = `${user2.firstname ?? ""} ${user2.lastname ?? ""}`.trim();
+  const mapped = {
+    id: String(user2.id),
+    name: name !== "" ? name : user2.name ?? String(user2.id)
+  };
+  if (user2.mail !== void 0 && user2.mail !== "") {
+    mapped.email = user2.mail;
+  }
+  return mapped;
+}
+function mapNamedUser(ref) {
+  return { id: String(ref.id), name: ref.name };
+}
+function categorizeStatus(status) {
+  if (status.is_closed === true) {
+    return "done";
+  }
+  if (/progress|doing|in work/i.test(status.name)) {
+    return "in_progress";
+  }
+  return "open";
+}
+function mapStatus2(ref, categories) {
+  if (ref === void 0) {
+    return { id: "", name: "", category: "unknown" };
+  }
+  return {
+    id: String(ref.id),
+    name: ref.name,
+    category: categories.get(ref.id) ?? "open"
+  };
+}
+function mapCustomField(field) {
+  if (field.multiple === true || Array.isArray(field.value)) {
+    const values = Array.isArray(field.value) ? field.value : field.value === null ? [] : [field.value];
+    return { type: "multi_enum", value: values.map((v) => ({ id: v, name: v })) };
+  }
+  if (field.value === null) {
+    return void 0;
+  }
+  return { type: "string", value: field.value };
+}
+function mapJournal(journal) {
+  const items = [];
+  const author = journal.user !== void 0 ? mapNamedUser(journal.user) : { id: "", name: "" };
+  if (journal.notes !== void 0 && journal.notes !== "") {
+    items.push({
+      kind: "comment",
+      id: `${journal.id}-note`,
+      author,
+      body: journal.notes,
+      createdAt: journal.created_on
+    });
+  }
+  const details = journal.details ?? [];
+  if (details.length > 0) {
+    items.push({
+      kind: "change",
+      id: `${journal.id}-change`,
+      author,
+      createdAt: journal.created_on,
+      changes: details.map((d) => ({
+        field: d.name,
+        from: d.old_value,
+        to: d.new_value
+      }))
+    });
+  }
+  return items;
+}
+function mapIssue2(issue, categories) {
+  const attributes2 = {};
+  for (const field of issue.custom_fields ?? []) {
+    const value = mapCustomField(field);
+    if (value !== void 0) {
+      attributes2[field.name] = value;
+    }
+  }
+  const items = [];
+  for (const journal of issue.journals ?? []) {
+    items.push(...mapJournal(journal));
+  }
+  const mapped = {
+    id: String(issue.id),
+    title: issue.subject,
+    description: issue.description ?? null,
+    status: mapStatus2(issue.status, categories),
+    author: issue.author !== void 0 ? mapNamedUser(issue.author) : null,
+    assignee: issue.assigned_to !== void 0 ? mapNamedUser(issue.assigned_to) : null,
+    attributes: attributes2,
+    items,
+    createdAt: issue.created_on,
+    updatedAt: issue.updated_on
+  };
+  if (issue.project !== void 0) {
+    mapped.projectId = String(issue.project.id);
+  }
+  return mapped;
+}
+function mapTimeEntry(entry) {
+  const mapped = {
+    id: String(entry.id),
+    issueId: entry.issue !== void 0 ? String(entry.issue.id) : "",
+    user: mapNamedUser(entry.user),
+    date: entry.spent_on,
+    durationMinutes: Math.round(entry.hours * 60),
+    createdAt: entry.created_on,
+    updatedAt: entry.updated_on
+  };
+  if (entry.comments !== void 0 && entry.comments !== "") {
+    mapped.description = entry.comments;
+  }
+  if (entry.activity !== void 0) {
+    mapped.activity = { id: String(entry.activity.id), name: entry.activity.name };
+  }
+  return mapped;
+}
+function attributeToRedmineValue(attr) {
+  switch (attr.type) {
+    case "string":
+    case "text":
+      return attr.value;
+    case "number":
+      return String(attr.value);
+    case "date":
+      return attr.value;
+    case "boolean":
+      return attr.value ? "1" : "0";
+    case "enum":
+      return attr.value.id;
+    case "multi_enum":
+      return attr.value.map((o) => o.id);
+    case "user":
+      return attr.value.id;
+  }
+}
+
+// ../redmine/dist/issuesTracker.js
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 25;
+var RedmineIssuesTracker = class {
+  client;
+  statusCache;
+  categoryCache;
+  constructor(client) {
+    this.client = client;
+  }
+  // Fetch and cache the issue-status definitions. Used both to derive status
+  // categories and to expose transitions.
+  async loadStatuses() {
+    if (this.statusCache === void 0) {
+      const res = await this.client.request("/issue_statuses.json");
+      this.statusCache = res.issue_statuses;
+    }
+    return this.statusCache;
+  }
+  // Build (and cache) the status-id to category lookup.
+  async categories() {
+    if (this.categoryCache === void 0) {
+      const statuses = await this.loadStatuses();
+      const map = /* @__PURE__ */ new Map();
+      for (const status of statuses) {
+        map.set(status.id, categorizeStatus(status));
+      }
+      this.categoryCache = map;
+    }
+    return this.categoryCache;
+  }
+  async capabilities() {
+    const fields = [];
+    const projectOptions = await this.fetchOptions(() => this.client.request("/projects.json", {
+      query: { limit: MAX_LIMIT }
+    }), (res) => res.projects);
+    fields.push({
+      id: "project",
+      name: "Project",
+      type: "enum",
+      required: true,
+      readOnly: false,
+      allowedValues: projectOptions
+    });
+    const trackerOptions = await this.fetchOptions(() => this.client.request("/trackers.json"), (res) => res.trackers);
+    fields.push({
+      id: "tracker",
+      name: "Tracker",
+      type: "enum",
+      required: true,
+      readOnly: false,
+      allowedValues: trackerOptions
+    });
+    fields.push({
+      id: "subject",
+      name: "Subject",
+      type: "string",
+      required: true,
+      readOnly: false
+    });
+    fields.push({
+      id: "description",
+      name: "Description",
+      type: "text",
+      required: false,
+      readOnly: false
+    });
+    const statuses = await this.loadStatuses();
+    fields.push({
+      id: "status",
+      name: "Status",
+      type: "enum",
+      required: false,
+      readOnly: false,
+      allowedValues: statuses.map((s) => ({ id: String(s.id), name: s.name }))
+    });
+    try {
+      const res = await this.client.request("/custom_fields.json");
+      for (const cf of res.custom_fields) {
+        fields.push({
+          id: `cf_${cf.id}`,
+          name: cf.name,
+          type: "string",
+          required: cf.is_required ?? false,
+          readOnly: false
+        });
+      }
+    } catch {
+    }
+    return {
+      canCreate: true,
+      canUpdate: true,
+      canDelete: true,
+      canComment: true,
+      canTransition: true,
+      fields
+    };
+  }
+  // Helper to fetch a reference list and map it to FieldOption[], swallowing
+  // failures (returns []) so capabilities() degrades gracefully.
+  async fetchOptions(fetcher, extract) {
+    try {
+      const res = await fetcher();
+      return extract(res).map((o) => ({ id: String(o.id), name: o.name }));
+    } catch {
+      return [];
+    }
+  }
+  async search(filter) {
+    const categories = await this.categories();
+    const limit = Math.min(filter.limit ?? DEFAULT_LIMIT, MAX_LIMIT);
+    const offset = filter.cursor !== void 0 ? Number(filter.cursor) : 0;
+    const startOffset = Number.isFinite(offset) && offset > 0 ? offset : 0;
+    const query = {
+      offset: startOffset,
+      limit
+    };
+    if (filter.projectId !== void 0) {
+      query["project_id"] = filter.projectId;
+    }
+    if (filter.assigneeId !== void 0) {
+      query["assigned_to_id"] = filter.assigneeId;
+    }
+    if (filter.authorId !== void 0) {
+      query["author_id"] = filter.authorId;
+    }
+    let clientSideInProgress = false;
+    if (filter.statusCategory === "open") {
+      query["status_id"] = "open";
+    } else if (filter.statusCategory === "done") {
+      query["status_id"] = "closed";
+    } else if (filter.statusCategory === "in_progress") {
+      query["status_id"] = "open";
+      clientSideInProgress = true;
+    }
+    const created = buildDateRange(filter.createdAfter, filter.createdBefore);
+    if (created !== void 0) {
+      query["created_on"] = created;
+    }
+    const updated = buildDateRange(filter.updatedAfter, filter.updatedBefore);
+    if (updated !== void 0) {
+      query["updated_on"] = updated;
+    }
+    if (filter.sort !== void 0) {
+      query["sort"] = `${filter.sort.field}:${filter.sort.dir}`;
+    }
+    if (filter.text !== void 0 && filter.text !== "") {
+      query["f[]"] = ["subject"];
+      query["op[subject]"] = "~";
+      query["v[subject][]"] = filter.text;
+    }
+    const res = await this.client.request("/issues.json", { query });
+    let items = res.issues.map((i) => mapIssue2(i, categories));
+    if (clientSideInProgress) {
+      items = items.filter((i) => i.status.category === "in_progress");
+    }
+    const page = { items, total: res.total_count };
+    const nextOffset = res.offset + res.limit;
+    if (nextOffset < res.total_count) {
+      page.nextCursor = String(nextOffset);
+    }
+    return page;
+  }
+  async get(id) {
+    const categories = await this.categories();
+    const res = await this.client.request(`/issues/${id}.json`, {
+      query: { include: "journals" }
+    });
+    return mapIssue2(res.issue, categories);
+  }
+  async create(input) {
+    const categories = await this.categories();
+    const attributes2 = input.attributes ?? {};
+    const trackerId = readEnumAttribute(attributes2, "tracker");
+    if (trackerId === void 0) {
+      throw new ValidationError("Redmine requires a `tracker` attribute (enum) to create an issue.");
+    }
+    const body = {
+      subject: input.title,
+      tracker_id: Number(trackerId)
+    };
+    if (input.projectId !== void 0) {
+      body.project_id = Number(input.projectId);
+    }
+    if (input.description !== void 0) {
+      body.description = input.description;
+    }
+    if (input.assigneeId !== void 0 && input.assigneeId !== null) {
+      body.assigned_to_id = Number(input.assigneeId);
+    }
+    const statusId = readEnumAttribute(attributes2, "status");
+    if (statusId !== void 0) {
+      body.status_id = Number(statusId);
+    }
+    const customFields = buildCustomFields(attributes2);
+    if (customFields.length > 0) {
+      body.custom_fields = customFields;
+    }
+    const res = await this.client.request("/issues.json", {
+      method: "POST",
+      body: { issue: body }
+    });
+    return mapIssue2(res.issue, categories);
+  }
+  async update(id, input) {
+    const body = {};
+    if (input.title !== void 0) {
+      body.subject = input.title;
+    }
+    if (input.description !== void 0) {
+      body.description = input.description;
+    }
+    if (input.projectId !== void 0) {
+      body.project_id = Number(input.projectId);
+    }
+    if (input.assigneeId !== void 0) {
+      body.assigned_to_id = input.assigneeId === null ? null : Number(input.assigneeId);
+    }
+    if (input.attributes !== void 0) {
+      const statusId = readEnumAttribute(input.attributes, "status");
+      if (statusId !== void 0) {
+        body.status_id = Number(statusId);
+      }
+      const customFields = buildCustomFields(input.attributes);
+      if (customFields.length > 0) {
+        body.custom_fields = customFields;
+      }
+    }
+    await this.client.request(`/issues/${id}.json`, {
+      method: "PUT",
+      body: { issue: body }
+    });
+    return this.get(id);
+  }
+  async delete(id) {
+    await this.client.request(`/issues/${id}.json`, { method: "DELETE" });
+  }
+  async addComment(issueId, body) {
+    await this.client.request(`/issues/${issueId}.json`, {
+      method: "PUT",
+      body: { issue: { notes: body } }
+    });
+    const res = await this.client.request(`/issues/${issueId}.json`, {
+      query: { include: "journals" }
+    });
+    const journals = res.issue.journals ?? [];
+    for (let i = journals.length - 1; i >= 0; i--) {
+      const journal = journals[i];
+      if (journal !== void 0 && journal.notes !== void 0 && journal.notes !== "") {
+        const comment = mapJournal(journal).find((item) => item.kind === "comment");
+        if (comment !== void 0) {
+          return comment;
+        }
+      }
+    }
+    throw new NotFoundError(`Comment was added to issue ${issueId} but could not be retrieved.`);
+  }
+  // Redmine does not enforce workflow transitions through the REST API: status
+  // is set directly. We therefore offer every issue status as a transition.
+  async getTransitions() {
+    const categories = await this.categories();
+    const statuses = await this.loadStatuses();
+    return statuses.map((s) => {
+      const to = mapStatus2({ id: s.id, name: s.name }, categories);
+      return { id: String(s.id), name: s.name, to };
+    });
+  }
+  async transition(issueId, transitionId) {
+    await this.client.request(`/issues/${issueId}.json`, {
+      method: "PUT",
+      body: { issue: { status_id: Number(transitionId) } }
+    });
+    return this.get(issueId);
+  }
+};
+function buildDateRange(after, before) {
+  if (after !== void 0 && before !== void 0) {
+    return `><${after}|${before}`;
+  }
+  if (after !== void 0) {
+    return `>=${after}`;
+  }
+  if (before !== void 0) {
+    return `<=${before}`;
+  }
+  return void 0;
+}
+function readEnumAttribute(attributes2, key) {
+  const attr = attributes2[key];
+  if (attr === void 0) {
+    return void 0;
+  }
+  if (attr.type === "enum") {
+    return attr.value.id;
+  }
+  if (attr.type === "string" || attr.type === "number") {
+    return String(attr.value);
+  }
+  return void 0;
+}
+function buildCustomFields(attributes2) {
+  const result = [];
+  for (const [key, attr] of Object.entries(attributes2)) {
+    const match = /^cf_(\d+)$/.exec(key);
+    if (match === null || match[1] === void 0) {
+      continue;
+    }
+    result.push({ id: Number(match[1]), value: attributeToRedmineValue(attr) });
+  }
+  return result;
+}
+
+// ../redmine/dist/timeTracker.js
+var MAX_LIMIT2 = 100;
+var DEFAULT_LIMIT2 = 25;
+var RedmineTimeTracker = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async capabilities() {
+    let activities = [];
+    try {
+      const res = await this.client.request("/enumerations/time_entry_activities.json");
+      activities = res.time_entry_activities.map((a) => ({ id: String(a.id), name: a.name }));
+    } catch {
+    }
+    return {
+      canCreate: true,
+      canUpdate: true,
+      canDelete: true,
+      requiresIssue: false,
+      activities
+    };
+  }
+  async search(filter) {
+    const limit = Math.min(filter.limit ?? DEFAULT_LIMIT2, MAX_LIMIT2);
+    const offset = filter.cursor !== void 0 ? Number(filter.cursor) : 0;
+    const startOffset = Number.isFinite(offset) && offset > 0 ? offset : 0;
+    const query = {
+      offset: startOffset,
+      limit
+    };
+    if (filter.issueId !== void 0) {
+      query["issue_id"] = filter.issueId;
+    }
+    if (filter.userId !== void 0) {
+      query["user_id"] = filter.userId;
+    }
+    if (filter.projectId !== void 0) {
+      query["project_id"] = filter.projectId;
+    }
+    if (filter.from !== void 0) {
+      query["from"] = filter.from;
+    }
+    if (filter.to !== void 0) {
+      query["to"] = filter.to;
+    }
+    if (filter.sort !== void 0) {
+      query["sort"] = `${filter.sort.field}:${filter.sort.dir}`;
+    }
+    const res = await this.client.request("/time_entries.json", {
+      query
+    });
+    const page = {
+      items: res.time_entries.map(mapTimeEntry),
+      total: res.total_count
+    };
+    const nextOffset = res.offset + res.limit;
+    if (nextOffset < res.total_count) {
+      page.nextCursor = String(nextOffset);
+    }
+    return page;
+  }
+  async get(id) {
+    const res = await this.client.request(`/time_entries/${id}.json`);
+    return mapTimeEntry(res.time_entry);
+  }
+  async create(input) {
+    const body = {
+      issue_id: Number(input.issueId),
+      hours: input.durationMinutes / 60,
+      spent_on: input.date
+    };
+    if (input.activityId !== void 0) {
+      body.activity_id = Number(input.activityId);
+    }
+    if (input.description !== void 0) {
+      body.comments = input.description;
+    }
+    const res = await this.client.request("/time_entries.json", {
+      method: "POST",
+      body: { time_entry: body }
+    });
+    return mapTimeEntry(res.time_entry);
+  }
+  async update(id, input) {
+    const body = {};
+    if (input.issueId !== void 0) {
+      body.issue_id = Number(input.issueId);
+    }
+    if (input.durationMinutes !== void 0) {
+      body.hours = input.durationMinutes / 60;
+    }
+    if (input.date !== void 0) {
+      body.spent_on = input.date;
+    }
+    if (input.activityId !== void 0) {
+      body.activity_id = Number(input.activityId);
+    }
+    if (input.description !== void 0) {
+      body.comments = input.description;
+    }
+    await this.client.request(`/time_entries/${id}.json`, {
+      method: "PUT",
+      body: { time_entry: body }
+    });
+    return this.get(id);
+  }
+  async delete(id) {
+    await this.client.request(`/time_entries/${id}.json`, { method: "DELETE" });
+  }
+};
+
+// ../redmine/dist/session.js
+var RedmineSession = class {
+  tracker;
+  user;
+  constructor(tracker, user2) {
+    this.tracker = tracker;
+    this.user = user2;
+  }
+  async currentUser() {
+    return this.user;
+  }
+  async close() {
+  }
+};
+var RedmineAuthenticator = class {
+  async authenticate(config) {
+    const client = new RedmineClient(config);
+    let user2;
+    try {
+      const res = await client.request("/users/current.json");
+      user2 = mapCurrentUser(res.user);
+    } catch (cause) {
+      if (cause instanceof AuthError) {
+        throw cause;
+      }
+      throw new AuthError(`Redmine credential validation failed: ${String(cause)}`, { cause });
+    }
+    const tracker = {
+      issues: new RedmineIssuesTracker(client),
+      time: new RedmineTimeTracker(client)
+    };
+    return new RedmineSession(tracker, user2);
+  }
+};
+
+// src/result.ts
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function fail(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+async function runTool(redact, fn) {
+  try {
+    return ok(await fn());
+  } catch (err) {
+    let message;
+    if (err instanceof IssueTrackerError) {
+      message = `${err.name}: ${err.message}`;
+    } else if (err instanceof Error) {
+      message = err.message;
+    } else {
+      message = String(err);
+    }
+    return fail(redact(message));
+  }
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var fieldOption = z.object({ id: z.string(), name: z.string() });
+var user = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().optional()
+});
+var attributeValue = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("string"), value: z.string() }),
+  z.object({ type: z.literal("text"), value: z.string() }),
+  z.object({ type: z.literal("number"), value: z.number() }),
+  z.object({ type: z.literal("date"), value: z.string() }),
+  z.object({ type: z.literal("boolean"), value: z.boolean() }),
+  z.object({ type: z.literal("enum"), value: fieldOption }),
+  z.object({ type: z.literal("multi_enum"), value: z.array(fieldOption) }),
+  z.object({ type: z.literal("user"), value: user })
+]);
+var attributes = z.record(z.string(), attributeValue);
+var statusCategory = z.enum(["open", "in_progress", "done", "unknown"]);
+var sort = z.object({ field: z.string(), dir: z.enum(["asc", "desc"]) });
+var issueFilterShape = {
+  text: z.string().optional(),
+  projectId: z.string().optional(),
+  statusCategory: statusCategory.optional(),
+  assigneeId: z.string().optional(),
+  authorId: z.string().optional(),
+  updatedAfter: z.string().optional(),
+  updatedBefore: z.string().optional(),
+  createdAfter: z.string().optional(),
+  createdBefore: z.string().optional(),
+  sort: sort.optional(),
+  limit: z.number().int().positive().optional(),
+  cursor: z.string().optional()
+};
+var getIssueShape = { id: z.string() };
+var createIssueShape = {
+  title: z.string(),
+  description: z.string().nullable().optional(),
+  projectId: z.string().optional(),
+  assigneeId: z.string().nullable().optional(),
+  attributes: attributes.optional()
+};
+var updateIssueShape = {
+  id: z.string(),
+  title: z.string().optional(),
+  description: z.string().nullable().optional(),
+  projectId: z.string().optional(),
+  assigneeId: z.string().nullable().optional(),
+  attributes: attributes.optional()
+};
+var deleteIssueShape = { id: z.string() };
+var addCommentShape = { issueId: z.string(), body: z.string() };
+var getTransitionsShape = { issueId: z.string() };
+var transitionShape = { issueId: z.string(), transitionId: z.string() };
+var timeEntryFilterShape = {
+  issueId: z.string().optional(),
+  userId: z.string().optional(),
+  projectId: z.string().optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  sort: sort.optional(),
+  limit: z.number().int().positive().optional(),
+  cursor: z.string().optional()
+};
+var getTimeEntryShape = { id: z.string() };
+var createTimeEntryShape = {
+  issueId: z.string(),
+  date: z.string(),
+  durationMinutes: z.number().positive(),
+  description: z.string().optional(),
+  activityId: z.string().optional(),
+  attributes: attributes.optional()
+};
+var updateTimeEntryShape = {
+  id: z.string(),
+  issueId: z.string().optional(),
+  date: z.string().optional(),
+  durationMinutes: z.number().positive().optional(),
+  description: z.string().optional(),
+  activityId: z.string().optional(),
+  attributes: attributes.optional()
+};
+var deleteTimeEntryShape = { id: z.string() };
+
+// src/tools.ts
+var READ_ONLY = { readOnlyHint: true };
+var DESTRUCTIVE = { destructiveHint: true };
+function registerTrackerTools(server, kind, session, redact) {
+  const { issues, time } = session.tracker;
+  const name = (op) => `${kind}_${op}`;
+  const run = (fn) => runTool(redact, fn);
+  server.registerTool(
+    name("whoami"),
+    {
+      title: `${kind}: current user`,
+      description: `Return the authenticated ${kind} account.`,
+      annotations: READ_ONLY
+    },
+    () => run(() => session.currentUser())
+  );
+  server.registerTool(
+    name("capabilities"),
+    {
+      title: `${kind}: capabilities`,
+      description: `Describe what the ${kind} tracker supports, including the fields accepted on create/update. Consult this before constructing a create_issue payload.`,
+      annotations: READ_ONLY
+    },
+    () => run(async () => ({
+      issues: await issues.capabilities(),
+      time: time ? await time.capabilities() : null
+    }))
+  );
+  server.registerTool(
+    name("search_issues"),
+    {
+      title: `${kind}: search issues`,
+      description: `Search ${kind} issues with a normalized filter. Returns a page of issues with an optional nextCursor.`,
+      inputSchema: issueFilterShape,
+      annotations: READ_ONLY
+    },
+    (args) => run(() => issues.search(args))
+  );
+  server.registerTool(
+    name("get_issue"),
+    {
+      title: `${kind}: get issue`,
+      description: `Fetch a single ${kind} issue by id (or key), including its timeline items.`,
+      inputSchema: getIssueShape,
+      annotations: READ_ONLY
+    },
+    ({ id }) => run(() => issues.get(id))
+  );
+  server.registerTool(
+    name("create_issue"),
+    {
+      title: `${kind}: create issue`,
+      description: `Create a ${kind} issue. Tracker-specific required fields go in \`attributes\`; check \`${kind}_capabilities\` first.`,
+      inputSchema: createIssueShape
+    },
+    (args) => run(() => issues.create(args))
+  );
+  server.registerTool(
+    name("update_issue"),
+    {
+      title: `${kind}: update issue`,
+      description: `Update fields on a ${kind} issue. Status is changed via transitions, not here.`,
+      inputSchema: updateIssueShape,
+      annotations: { idempotentHint: true }
+    },
+    ({ id, ...input }) => run(() => issues.update(id, input))
+  );
+  server.registerTool(
+    name("delete_issue"),
+    {
+      title: `${kind}: delete issue`,
+      description: `Permanently delete a ${kind} issue.`,
+      inputSchema: deleteIssueShape,
+      annotations: DESTRUCTIVE
+    },
+    ({ id }) => run(() => issues.delete(id).then(() => ({ deleted: id })))
+  );
+  server.registerTool(
+    name("add_comment"),
+    {
+      title: `${kind}: add comment`,
+      description: `Add a comment to a ${kind} issue.`,
+      inputSchema: addCommentShape
+    },
+    ({ issueId, body }) => run(() => issues.addComment(issueId, body))
+  );
+  server.registerTool(
+    name("get_transitions"),
+    {
+      title: `${kind}: get transitions`,
+      description: `List the status transitions currently available for a ${kind} issue.`,
+      inputSchema: getTransitionsShape,
+      annotations: READ_ONLY
+    },
+    ({ issueId }) => run(() => issues.getTransitions(issueId))
+  );
+  server.registerTool(
+    name("transition_issue"),
+    {
+      title: `${kind}: transition issue`,
+      description: `Move a ${kind} issue through a transition (use get_transitions for valid ids).`,
+      inputSchema: transitionShape
+    },
+    ({ issueId, transitionId }) => run(() => issues.transition(issueId, transitionId))
+  );
+  if (!time) return;
+  server.registerTool(
+    name("search_time_entries"),
+    {
+      title: `${kind}: search time entries`,
+      description: `Search ${kind} time entries with a normalized filter.`,
+      inputSchema: timeEntryFilterShape,
+      annotations: READ_ONLY
+    },
+    (args) => run(() => time.search(args))
+  );
+  server.registerTool(
+    name("get_time_entry"),
+    {
+      title: `${kind}: get time entry`,
+      description: `Fetch a single ${kind} time entry by id.`,
+      inputSchema: getTimeEntryShape,
+      annotations: READ_ONLY
+    },
+    ({ id }) => run(() => time.get(id))
+  );
+  server.registerTool(
+    name("create_time_entry"),
+    {
+      title: `${kind}: log time`,
+      description: `Log a ${kind} time entry against an issue. durationMinutes is in minutes.`,
+      inputSchema: createTimeEntryShape
+    },
+    (args) => run(() => time.create(args))
+  );
+  server.registerTool(
+    name("update_time_entry"),
+    {
+      title: `${kind}: update time entry`,
+      description: `Update a ${kind} time entry.`,
+      inputSchema: updateTimeEntryShape,
+      annotations: { idempotentHint: true }
+    },
+    ({ id, ...input }) => run(() => time.update(id, input))
+  );
+  server.registerTool(
+    name("delete_time_entry"),
+    {
+      title: `${kind}: delete time entry`,
+      description: `Permanently delete a ${kind} time entry.`,
+      inputSchema: deleteTimeEntryShape,
+      annotations: DESTRUCTIVE
+    },
+    ({ id }) => run(() => time.delete(id).then(() => ({ deleted: id })))
+  );
+}
+
+// src/server.ts
+var AUTHENTICATORS = {
+  jira: () => new JiraAuthenticator(),
+  redmine: () => new RedmineAuthenticator()
+};
+async function createServer(env = process.env) {
+  const { trackers, secrets, warnings: configWarnings } = loadConfig(env);
+  const redact = makeRedactor(secrets);
+  const server = new McpServer({ name: "issues-mcp", version: "1.0.0" });
+  const sessions = [];
+  const warnings = [...configWarnings];
+  for (const { kind, connection } of trackers) {
+    try {
+      const session = await AUTHENTICATORS[kind]().authenticate(connection);
+      sessions.push(session);
+      registerTrackerTools(server, kind, session, redact);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      warnings.push(`${kind}: authentication failed \u2014 ${redact(message)}`);
+    }
+  }
+  return { server, sessions, warnings };
+}
+
+export {
+  loadConfig,
+  makeRedactor,
+  createServer
+};
+//# sourceMappingURL=chunk-Y53ZARWV.js.map