@universal-mcp-toolkit/server-linear 0.1.0

package/dist/index.js

@@ -0,0 +1,985 @@
+// src/index.ts
+import { pathToFileURL } from "url";
+import {
+  ConfigurationError,
+  ExternalServiceError,
+  ValidationError,
+  createServerCard,
+  defineTool,
+  loadEnv,
+  normalizeError,
+  parseRuntimeOptions,
+  runToolkitServer,
+  ToolkitServer
+} from "@universal-mcp-toolkit/core";
+import { z } from "zod";
+var DEFAULT_LINEAR_API_URL = "https://api.linear.app/graphql";
+var TEAM_RESOURCE_URI = "linear://team/default";
+var TOOL_NAMES = ["search_issues", "get_issue", "create_issue"];
+var RESOURCE_NAMES = ["team"];
+var PROMPT_NAMES = ["sprint-triage"];
+function preprocessOptionalTrimmedString(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+var requiredTrimmedStringSchema = z.string().trim().min(1);
+var optionalTrimmedStringSchema = z.preprocess(preprocessOptionalTrimmedString, z.string().min(1).optional());
+var optionalTeamKeySchema = z.preprocess((value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized.length === 0 ? void 0 : normalized;
+}, z.string().min(1).optional());
+var optionalUrlSchema = z.preprocess(preprocessOptionalTrimmedString, z.string().url().optional());
+var dueDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected YYYY-MM-DD.");
+var linearEnvShape = {
+  LINEAR_API_KEY: requiredTrimmedStringSchema,
+  LINEAR_DEFAULT_TEAM_ID: optionalTrimmedStringSchema,
+  LINEAR_DEFAULT_TEAM_KEY: optionalTeamKeySchema,
+  LINEAR_WORKSPACE_NAME: optionalTrimmedStringSchema,
+  LINEAR_API_URL: optionalUrlSchema
+};
+var teamShape = {
+  id: z.string(),
+  key: z.string(),
+  name: z.string()
+};
+var teamSchema = z.object(teamShape);
+var userShape = {
+  id: z.string(),
+  name: z.string()
+};
+var userSchema = z.object(userShape);
+var issueStateShape = {
+  name: z.string().nullable(),
+  type: z.string().nullable()
+};
+var issueStateSchema = z.object(issueStateShape);
+var issueCycleShape = {
+  id: z.string(),
+  number: z.number().int().nullable(),
+  name: z.string().nullable(),
+  startsAt: z.string().nullable(),
+  endsAt: z.string().nullable()
+};
+var issueCycleSchema = z.object(issueCycleShape);
+var issueSummaryShape = {
+  id: z.string(),
+  identifier: z.string(),
+  title: z.string(),
+  url: z.string().nullable(),
+  priority: z.number().int().nullable(),
+  state: issueStateSchema,
+  team: teamSchema.nullable(),
+  assignee: userSchema.nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable()
+};
+var issueSummarySchema = z.object(issueSummaryShape);
+var issueDetailShape = {
+  ...issueSummaryShape,
+  description: z.string().nullable(),
+  branchName: z.string().nullable(),
+  cycle: issueCycleSchema.nullable()
+};
+var issueDetailSchema = z.object(issueDetailShape);
+var searchIssuesInputShape = {
+  query: requiredTrimmedStringSchema,
+  limit: z.number().int().min(1).max(50).default(10),
+  teamId: optionalTrimmedStringSchema,
+  teamKey: optionalTeamKeySchema,
+  stateName: optionalTrimmedStringSchema
+};
+var searchIssuesOutputShape = {
+  query: z.string(),
+  stateName: z.string().nullable(),
+  team: teamSchema.nullable(),
+  warning: z.string().nullable(),
+  total: z.number().int().nonnegative(),
+  issues: z.array(issueSummarySchema)
+};
+var getIssueInputShape = {
+  idOrIdentifier: requiredTrimmedStringSchema
+};
+var getIssueOutputShape = {
+  issue: issueDetailSchema
+};
+var createIssueInputShape = {
+  title: requiredTrimmedStringSchema,
+  description: optionalTrimmedStringSchema,
+  teamId: optionalTrimmedStringSchema,
+  teamKey: optionalTeamKeySchema,
+  priority: z.number().int().min(0).max(4).optional(),
+  stateId: optionalTrimmedStringSchema,
+  assigneeId: optionalTrimmedStringSchema,
+  labelIds: z.array(requiredTrimmedStringSchema).max(25).optional(),
+  dueDate: dueDateSchema.optional(),
+  projectId: optionalTrimmedStringSchema,
+  cycleId: optionalTrimmedStringSchema
+};
+var createIssueOutputShape = {
+  created: z.boolean(),
+  issue: issueDetailSchema
+};
+var sprintTriagePromptArgsShape = {
+  teamId: optionalTrimmedStringSchema,
+  teamKey: optionalTeamKeySchema,
+  focus: optionalTrimmedStringSchema,
+  objective: optionalTrimmedStringSchema,
+  issueLimit: z.number().int().min(1).max(25).default(10),
+  includeBacklog: z.boolean().default(true)
+};
+var graphQlIssueStateSchema = z.object({
+  name: z.string(),
+  type: z.string().nullable().optional()
+});
+var graphQlIssueCycleSchema = z.object({
+  id: z.string(),
+  number: z.number().int().nullable().optional(),
+  name: z.string().nullable().optional(),
+  startsAt: z.string().nullable().optional(),
+  endsAt: z.string().nullable().optional()
+});
+var graphQlIssueSchema = z.object({
+  id: z.string(),
+  identifier: z.string(),
+  title: z.string(),
+  description: z.string().nullable().optional(),
+  url: z.string().nullable().optional(),
+  branchName: z.string().nullable().optional(),
+  priority: z.number().int().nullable().optional(),
+  createdAt: z.string().nullable().optional(),
+  updatedAt: z.string().nullable().optional(),
+  state: graphQlIssueStateSchema.nullable().optional(),
+  team: teamSchema.nullable().optional(),
+  assignee: userSchema.nullable().optional(),
+  cycle: graphQlIssueCycleSchema.nullable().optional()
+});
+var graphQlErrorSchema = z.object({
+  message: z.string(),
+  path: z.array(z.union([z.string(), z.number()])).optional(),
+  extensions: z.record(z.string(), z.unknown()).optional()
+});
+function createGraphQlEnvelopeSchema(dataSchema) {
+  return z.object({
+    data: dataSchema.optional(),
+    errors: z.array(graphQlErrorSchema).optional()
+  });
+}
+function normalizeTeamKey(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized.length === 0 ? void 0 : normalized;
+}
+function withOptionalProperty(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function parseIssueIdentifier(value) {
+  const match = /^([A-Za-z][A-Za-z0-9]+)-(\d+)$/.exec(value.trim());
+  if (!match) {
+    return null;
+  }
+  const [, rawTeamKey, rawIssueNumber] = match;
+  if (rawTeamKey === void 0 || rawIssueNumber === void 0) {
+    return null;
+  }
+  const issueNumber = Number.parseInt(rawIssueNumber, 10);
+  if (!Number.isSafeInteger(issueNumber)) {
+    return null;
+  }
+  return {
+    teamKey: rawTeamKey.toUpperCase(),
+    number: issueNumber
+  };
+}
+function readUnknownRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function readStatusCode(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+  }
+  return void 0;
+}
+function extractGraphQlErrorStatus(error) {
+  const extensions = error.extensions;
+  if (!extensions) {
+    return void 0;
+  }
+  const directStatus = readStatusCode(extensions.statusCode) ?? readStatusCode(extensions.status);
+  if (directStatus !== void 0) {
+    return directStatus;
+  }
+  const httpExtensions = readUnknownRecord(extensions.http);
+  return httpExtensions ? readStatusCode(httpExtensions.status) : void 0;
+}
+function buildGraphQlError(operationName, errors, fallbackStatusCode = 502) {
+  const statusCode = errors.map((error) => extractGraphQlErrorStatus(error)).find((value) => value !== void 0) ?? fallbackStatusCode;
+  return new ExternalServiceError(`Linear ${operationName} failed: ${errors.map((error) => error.message).join("; ")}`, {
+    statusCode,
+    details: errors
+  });
+}
+function normalizeIssue(issue) {
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    description: issue.description ?? null,
+    url: issue.url ?? null,
+    branchName: issue.branchName ?? null,
+    priority: issue.priority ?? null,
+    state: {
+      name: issue.state?.name ?? null,
+      type: issue.state?.type ?? null
+    },
+    team: issue.team ?? null,
+    assignee: issue.assignee ?? null,
+    cycle: issue.cycle ? {
+      id: issue.cycle.id,
+      number: issue.cycle.number ?? null,
+      name: issue.cycle.name ?? null,
+      startsAt: issue.cycle.startsAt ?? null,
+      endsAt: issue.cycle.endsAt ?? null
+    } : null,
+    createdAt: issue.createdAt ?? null,
+    updatedAt: issue.updatedAt ?? null
+  };
+}
+function toIssueSummary(issue) {
+  return {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    url: issue.url,
+    priority: issue.priority,
+    state: issue.state,
+    team: issue.team,
+    assignee: issue.assignee,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt
+  };
+}
+function renderIssueHeadline(issue) {
+  const parts = [`${issue.identifier}: ${issue.title}`];
+  if (issue.state.name) {
+    parts.push(`[${issue.state.name}]`);
+  }
+  if (issue.assignee) {
+    parts.push(`@${issue.assignee.name}`);
+  }
+  return parts.join(" ");
+}
+function renderSearchIssuesOutput(output) {
+  const headerParts = [`Found ${output.total} Linear issue${output.total === 1 ? "" : "s"} for "${output.query}"`];
+  if (output.team) {
+    headerParts.push(`in ${output.team.name} (${output.team.key})`);
+  }
+  if (output.stateName) {
+    headerParts.push(`with state ${output.stateName}`);
+  }
+  const lines = [`${headerParts.join(" ")}.`];
+  if (output.warning) {
+    lines.push(`Warning: ${output.warning}`);
+  }
+  if (output.total === 0) {
+    return lines.join("\n");
+  }
+  for (const issue of output.issues) {
+    lines.push(`- ${renderIssueHeadline(issue)}`);
+  }
+  return lines.join("\n");
+}
+function renderGetIssueOutput(output) {
+  const { issue } = output;
+  const lines = [renderIssueHeadline(issue)];
+  if (issue.team) {
+    lines.push(`Team: ${issue.team.name} (${issue.team.key})`);
+  }
+  if (issue.url) {
+    lines.push(`URL: ${issue.url}`);
+  }
+  if (issue.branchName) {
+    lines.push(`Branch: ${issue.branchName}`);
+  }
+  if (issue.cycle?.name) {
+    lines.push(`Cycle: ${issue.cycle.name}`);
+  }
+  if (issue.description) {
+    lines.push("", issue.description);
+  }
+  return lines.join("\n");
+}
+function renderCreateIssueOutput(output) {
+  const { issue } = output;
+  const lines = [`Created Linear issue ${issue.identifier}: ${issue.title}`];
+  if (issue.team) {
+    lines.push(`Team: ${issue.team.name} (${issue.team.key})`);
+  }
+  if (issue.url) {
+    lines.push(`URL: ${issue.url}`);
+  }
+  return lines.join("\n");
+}
+var TEAM_FIELDS = `
+  id
+  key
+  name
+`;
+var ISSUE_SUMMARY_FIELDS = `
+  id
+  identifier
+  title
+  url
+  priority
+  createdAt
+  updatedAt
+  state {
+    name
+    type
+  }
+  team {
+    ${TEAM_FIELDS}
+  }
+  assignee {
+    id
+    name
+  }
+`;
+var ISSUE_DETAIL_FIELDS = `
+  ${ISSUE_SUMMARY_FIELDS}
+  description
+  branchName
+  cycle {
+    id
+    number
+    name
+    startsAt
+    endsAt
+  }
+`;
+var LIST_TEAMS_QUERY = `
+  query ListTeams($first: Int!) {
+    teams(first: $first) {
+      nodes {
+        ${TEAM_FIELDS}
+      }
+    }
+  }
+`;
+var SEARCH_ISSUES_QUERY = `
+  query SearchIssues($filter: IssueFilter, $first: Int!) {
+    issues(filter: $filter, first: $first, orderBy: updatedAt) {
+      nodes {
+        ${ISSUE_SUMMARY_FIELDS}
+      }
+    }
+  }
+`;
+var GET_ISSUE_QUERY = `
+  query GetIssue($id: String!) {
+    issue(id: $id) {
+      ${ISSUE_DETAIL_FIELDS}
+    }
+  }
+`;
+var FIND_ISSUE_BY_IDENTIFIER_QUERY = `
+  query FindIssueByIdentifier($filter: IssueFilter, $first: Int!) {
+    issues(filter: $filter, first: $first) {
+      nodes {
+        ${ISSUE_DETAIL_FIELDS}
+      }
+    }
+  }
+`;
+var CREATE_ISSUE_MUTATION = `
+  mutation CreateIssue($input: IssueCreateInput!) {
+    issueCreate(input: $input) {
+      success
+      issue {
+        ${ISSUE_DETAIL_FIELDS}
+      }
+    }
+  }
+`;
+var listTeamsResponseSchema = z.object({
+  teams: z.object({
+    nodes: z.array(teamSchema)
+  })
+});
+var searchIssuesResponseSchema = z.object({
+  issues: z.object({
+    nodes: z.array(graphQlIssueSchema)
+  })
+});
+var getIssueResponseSchema = z.object({
+  issue: graphQlIssueSchema.nullable()
+});
+var createIssueResponseSchema = z.object({
+  issueCreate: z.object({
+    success: z.boolean(),
+    issue: graphQlIssueSchema.nullable()
+  })
+});
+var LinearApiClient = class {
+  apiKey;
+  apiUrl;
+  fetchFn;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiUrl = options.apiUrl ?? DEFAULT_LINEAR_API_URL;
+    this.fetchFn = options.fetchFn ?? fetch;
+  }
+  async listTeams() {
+    const response = await this.request("ListTeams", LIST_TEAMS_QUERY, { first: 100 }, listTeamsResponseSchema);
+    return [...response.teams.nodes].sort((left, right) => left.key.localeCompare(right.key));
+  }
+  async searchIssues(input) {
+    const filter = {};
+    if (input.teamId) {
+      filter.team = { id: { eq: input.teamId } };
+    }
+    if (input.stateName) {
+      filter.state = { name: { eq: input.stateName } };
+    }
+    if (input.issueNumber !== void 0) {
+      filter.number = { eq: input.issueNumber };
+    } else {
+      filter.title = { containsIgnoreCase: input.query };
+    }
+    const response = await this.request("SearchIssues", SEARCH_ISSUES_QUERY, { filter, first: input.limit }, searchIssuesResponseSchema);
+    return response.issues.nodes.map((issue) => toIssueSummary(normalizeIssue(issue)));
+  }
+  async getIssueById(id) {
+    const response = await this.request("GetIssue", GET_ISSUE_QUERY, { id }, getIssueResponseSchema);
+    if (!response.issue) {
+      throw new ExternalServiceError(`Linear issue '${id}' was not found.`, {
+        statusCode: 404,
+        details: { id }
+      });
+    }
+    return normalizeIssue(response.issue);
+  }
+  async getIssueByIdentifier(teamId, issueNumber) {
+    const filter = {
+      team: { id: { eq: teamId } },
+      number: { eq: issueNumber }
+    };
+    const response = await this.request(
+      "FindIssueByIdentifier",
+      FIND_ISSUE_BY_IDENTIFIER_QUERY,
+      { filter, first: 1 },
+      searchIssuesResponseSchema
+    );
+    const issue = response.issues.nodes[0];
+    if (!issue) {
+      throw new ExternalServiceError(`Linear issue '${issueNumber}' was not found for team '${teamId}'.`, {
+        statusCode: 404,
+        details: { teamId, issueNumber }
+      });
+    }
+    return normalizeIssue(issue);
+  }
+  async createIssue(input) {
+    const mutationInput = {
+      title: input.title,
+      teamId: input.teamId
+    };
+    if (input.description !== void 0) {
+      mutationInput.description = input.description;
+    }
+    if (input.priority !== void 0) {
+      mutationInput.priority = input.priority;
+    }
+    if (input.stateId !== void 0) {
+      mutationInput.stateId = input.stateId;
+    }
+    if (input.assigneeId !== void 0) {
+      mutationInput.assigneeId = input.assigneeId;
+    }
+    if (input.labelIds !== void 0) {
+      mutationInput.labelIds = input.labelIds;
+    }
+    if (input.dueDate !== void 0) {
+      mutationInput.dueDate = input.dueDate;
+    }
+    if (input.projectId !== void 0) {
+      mutationInput.projectId = input.projectId;
+    }
+    if (input.cycleId !== void 0) {
+      mutationInput.cycleId = input.cycleId;
+    }
+    const response = await this.request("CreateIssue", CREATE_ISSUE_MUTATION, { input: mutationInput }, createIssueResponseSchema);
+    if (!response.issueCreate.success || !response.issueCreate.issue) {
+      throw new ExternalServiceError("Linear did not confirm that the issue was created.", {
+        statusCode: 502,
+        details: response.issueCreate
+      });
+    }
+    return normalizeIssue(response.issueCreate.issue);
+  }
+  async request(operationName, query, variables, dataSchema) {
+    let response;
+    try {
+      response = await this.fetchFn(this.apiUrl, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${this.apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ query, variables })
+      });
+    } catch (error) {
+      const normalized = normalizeError(error);
+      throw new ExternalServiceError(`Could not reach the Linear API while running ${operationName}.`, {
+        statusCode: 502,
+        details: {
+          message: normalized.message,
+          details: normalized.details
+        }
+      });
+    }
+    const rawBody = await response.text();
+    let payload = {};
+    if (rawBody.length > 0) {
+      try {
+        payload = JSON.parse(rawBody);
+      } catch {
+        throw new ExternalServiceError(`Linear returned invalid JSON for ${operationName}.`, {
+          statusCode: response.status || 502,
+          details: rawBody.slice(0, 2e3)
+        });
+      }
+    }
+    const looseErrorEnvelope = createGraphQlEnvelopeSchema(z.unknown());
+    const parsedLooseEnvelope = looseErrorEnvelope.safeParse(payload);
+    if (!response.ok) {
+      if (parsedLooseEnvelope.success && parsedLooseEnvelope.data.errors?.length) {
+        throw buildGraphQlError(operationName, parsedLooseEnvelope.data.errors, response.status);
+      }
+      throw new ExternalServiceError(`Linear returned HTTP ${response.status} for ${operationName}.`, {
+        statusCode: response.status,
+        details: payload
+      });
+    }
+    const envelopeSchema = createGraphQlEnvelopeSchema(dataSchema);
+    const parsedEnvelope = envelopeSchema.safeParse(payload);
+    if (!parsedEnvelope.success) {
+      throw new ExternalServiceError(`Linear returned an unexpected payload for ${operationName}.`, {
+        details: parsedEnvelope.error.flatten()
+      });
+    }
+    if (parsedEnvelope.data.errors?.length) {
+      throw buildGraphQlError(operationName, parsedEnvelope.data.errors);
+    }
+    if (parsedEnvelope.data.data === void 0) {
+      throw new ExternalServiceError(`Linear returned no data for ${operationName}.`, {
+        details: payload
+      });
+    }
+    return parsedEnvelope.data.data;
+  }
+};
+var metadata = {
+  id: "linear",
+  title: "Linear MCP Server",
+  description: "Search, inspect, create, and triage Linear issues with team resources and prompts.",
+  version: "0.1.0",
+  packageName: "@universal-mcp-toolkit/server-linear",
+  homepage: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit#readme",
+  repositoryUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  documentationUrl: "https://developers.linear.app/docs/graphql",
+  envVarNames: [
+    "LINEAR_API_KEY",
+    "LINEAR_DEFAULT_TEAM_ID",
+    "LINEAR_DEFAULT_TEAM_KEY",
+    "LINEAR_WORKSPACE_NAME",
+    "LINEAR_API_URL"
+  ],
+  transports: ["stdio", "sse"],
+  toolNames: TOOL_NAMES,
+  resourceNames: RESOURCE_NAMES,
+  promptNames: PROMPT_NAMES
+};
+var serverCard = createServerCard(metadata);
+var LinearServer = class extends ToolkitServer {
+  client;
+  defaultTeamId;
+  defaultTeamKey;
+  workspaceName;
+  constructor(options) {
+    super(metadata);
+    this.client = options.client;
+    this.defaultTeamId = options.defaultTeamId ?? null;
+    this.defaultTeamKey = normalizeTeamKey(options.defaultTeamKey) ?? null;
+    this.workspaceName = options.workspaceName ?? null;
+    this.registerSearchIssuesTool();
+    this.registerGetIssueTool();
+    this.registerCreateIssueTool();
+    this.registerTeamResource();
+    this.registerSprintTriagePrompt();
+  }
+  async getTeamResourcePayload() {
+    return this.runOperation("load the Linear team resource", async () => {
+      const selection = await this.resolveTeamSelection({
+        useDefaults: true
+      });
+      return {
+        workspaceName: this.workspaceName,
+        configuredDefaultTeamId: this.defaultTeamId,
+        configuredDefaultTeamKey: this.defaultTeamKey,
+        defaultTeam: selection.team,
+        accessibleTeams: selection.teams,
+        warning: selection.warning
+      };
+    });
+  }
+  async createSprintTriagePrompt(args = {}) {
+    return this.runOperation("create the sprint triage prompt", async () => {
+      const selectionOptions = {
+        useDefaults: true,
+        strictOnMissing: args.teamId !== void 0 || args.teamKey !== void 0,
+        ...withOptionalProperty("teamId", args.teamId),
+        ...withOptionalProperty("teamKey", args.teamKey)
+      };
+      const selection = await this.resolveTeamSelection(selectionOptions);
+      const issueLimit = args.issueLimit ?? 10;
+      const includeBacklog = args.includeBacklog ?? true;
+      const selectedTeamLabel = selection.team ? `${selection.team.name} (${selection.team.key})` : "No default team selected";
+      const accessibleTeams = selection.teams.length > 0 ? selection.teams.map((team) => `${team.name} (${team.key})`).join(", ") : "No teams were returned for this API token.";
+      const text = [
+        `You are preparing sprint triage for the Linear workspace ${this.workspaceName ?? "associated with the current API token"}.`,
+        `Primary team context: ${selectedTeamLabel}.`,
+        `Accessible teams: ${accessibleTeams}`,
+        `Objective: ${args.objective ?? "Review the next sprint, identify the right scope, and flag any missing work."}`,
+        `Focus area: ${args.focus ?? "overall sprint health, priorities, and blockers"}.`,
+        `Review up to ${issueLimit} issues.`,
+        includeBacklog ? "Include realistic backlog carry-over items if they are important for the next sprint." : "Exclude backlog carry-over items unless they are direct blockers for sprint goals.",
+        "Use the available Linear capabilities in this order:",
+        "1. Read the team resource at linear://team/default for team context.",
+        "2. Use search_issues to gather candidate sprint work.",
+        "3. Use get_issue for any issue that needs deeper inspection.",
+        "4. Suggest create_issue actions for gaps, follow-up work, or missing dependencies.",
+        "Return the triage plan grouped into: must ship, stretch, defer, blockers, and missing issues.",
+        selection.warning ? `Warning: ${selection.warning}` : void 0,
+        "Current team snapshot:",
+        JSON.stringify(
+          {
+            workspaceName: this.workspaceName,
+            selectedTeam: selection.team,
+            accessibleTeams: selection.teams
+          },
+          null,
+          2
+        )
+      ].filter((line) => line !== void 0).join("\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text
+            }
+          }
+        ]
+      };
+    });
+  }
+  registerSearchIssuesTool() {
+    this.registerTool(
+      defineTool({
+        name: "search_issues",
+        title: "Search Linear issues",
+        description: "Search Linear issues by title or exact issue identifier, optionally scoped to a team or state.",
+        inputSchema: searchIssuesInputShape,
+        outputSchema: searchIssuesOutputShape,
+        handler: async (input, context) => this.runOperation("search Linear issues", async () => {
+          const identifier = parseIssueIdentifier(input.query);
+          const requestedTeamKey = input.teamKey;
+          if (identifier && requestedTeamKey && normalizeTeamKey(requestedTeamKey) !== identifier.teamKey) {
+            throw new ValidationError(
+              `The issue identifier '${input.query}' targets team '${identifier.teamKey}', which does not match teamKey '${requestedTeamKey}'.`
+            );
+          }
+          await context.log("info", `Searching Linear issues for '${input.query}'.`);
+          const selectionOptions = {
+            useDefaults: input.teamId === void 0 && requestedTeamKey === void 0 && identifier === null,
+            strictOnMissing: input.teamId !== void 0 || requestedTeamKey !== void 0 || identifier !== null,
+            ...withOptionalProperty("teamId", input.teamId),
+            ...withOptionalProperty("teamKey", requestedTeamKey ?? identifier?.teamKey)
+          };
+          const selection = await this.resolveTeamSelection(selectionOptions);
+          const searchRequest = {
+            query: input.query,
+            limit: input.limit,
+            ...withOptionalProperty("stateName", input.stateName),
+            ...withOptionalProperty("teamId", selection.team?.id),
+            ...withOptionalProperty("issueNumber", identifier?.number)
+          };
+          const issues = await this.client.searchIssues(searchRequest);
+          await context.log("info", `Linear returned ${issues.length} issue(s).`);
+          return {
+            query: input.query,
+            stateName: input.stateName ?? null,
+            team: selection.team,
+            warning: selection.warning,
+            total: issues.length,
+            issues
+          };
+        }),
+        renderText: renderSearchIssuesOutput
+      })
+    );
+  }
+  registerGetIssueTool() {
+    this.registerTool(
+      defineTool({
+        name: "get_issue",
+        title: "Get a Linear issue",
+        description: "Get a Linear issue by UUID/id or by issue identifier such as ENG-123.",
+        inputSchema: getIssueInputShape,
+        outputSchema: getIssueOutputShape,
+        handler: async (input, context) => this.runOperation("get a Linear issue", async () => {
+          await context.log("info", `Loading Linear issue '${input.idOrIdentifier}'.`);
+          const parsedIdentifier = parseIssueIdentifier(input.idOrIdentifier);
+          const issue = parsedIdentifier === null ? await this.client.getIssueById(input.idOrIdentifier) : await this.getIssueByTeamKeyAndNumber(parsedIdentifier.teamKey, parsedIdentifier.number);
+          await context.log("info", `Loaded Linear issue '${issue.identifier}'.`);
+          return { issue };
+        }),
+        renderText: renderGetIssueOutput
+      })
+    );
+  }
+  registerCreateIssueTool() {
+    this.registerTool(
+      defineTool({
+        name: "create_issue",
+        title: "Create a Linear issue",
+        description: "Create a new Linear issue using an explicit team or the configured default team.",
+        inputSchema: createIssueInputShape,
+        outputSchema: createIssueOutputShape,
+        handler: async (input, context) => this.runOperation("create a Linear issue", async () => {
+          const selectionOptions = {
+            useDefaults: true,
+            requireResolved: true,
+            strictOnMissing: true,
+            ...withOptionalProperty("teamId", input.teamId),
+            ...withOptionalProperty("teamKey", input.teamKey)
+          };
+          const selection = await this.resolveTeamSelection(selectionOptions);
+          if (!selection.team) {
+            throw new ConfigurationError(
+              "A Linear team is required to create issues. Provide teamId/teamKey or configure LINEAR_DEFAULT_TEAM_ID or LINEAR_DEFAULT_TEAM_KEY."
+            );
+          }
+          await context.log("info", `Creating a Linear issue in team '${selection.team.key}'.`);
+          const createIssueInput = {
+            teamId: selection.team.id,
+            title: input.title,
+            ...withOptionalProperty("description", input.description),
+            ...withOptionalProperty("priority", input.priority),
+            ...withOptionalProperty("stateId", input.stateId),
+            ...withOptionalProperty("assigneeId", input.assigneeId),
+            ...withOptionalProperty("labelIds", input.labelIds),
+            ...withOptionalProperty("dueDate", input.dueDate),
+            ...withOptionalProperty("projectId", input.projectId),
+            ...withOptionalProperty("cycleId", input.cycleId)
+          };
+          const issue = await this.client.createIssue(createIssueInput);
+          await context.log("info", `Created Linear issue '${issue.identifier}'.`);
+          return {
+            created: true,
+            issue
+          };
+        }),
+        renderText: renderCreateIssueOutput
+      })
+    );
+  }
+  registerTeamResource() {
+    this.registerStaticResource(
+      "team",
+      TEAM_RESOURCE_URI,
+      {
+        title: "Linear team context",
+        description: "JSON summary of accessible Linear teams and the configured default team.",
+        mimeType: "application/json"
+      },
+      async (uri) => this.createJsonResource(uri.toString(), await this.getTeamResourcePayload())
+    );
+  }
+  registerSprintTriagePrompt() {
+    this.registerPrompt(
+      "sprint-triage",
+      {
+        title: "Sprint triage",
+        description: "Create a sprint triage prompt grounded in the current Linear team context.",
+        argsSchema: sprintTriagePromptArgsShape
+      },
+      async (args) => this.createSprintTriagePrompt(args)
+    );
+  }
+  async getIssueByTeamKeyAndNumber(teamKey, issueNumber) {
+    const selection = await this.resolveTeamSelection({
+      teamKey,
+      requireResolved: true,
+      strictOnMissing: true
+    });
+    if (!selection.team) {
+      throw new ExternalServiceError(`Linear team '${teamKey}' was not found.`, {
+        statusCode: 404,
+        details: { teamKey }
+      });
+    }
+    return this.client.getIssueByIdentifier(selection.team.id, issueNumber);
+  }
+  async resolveTeamSelection(options) {
+    const teams = await this.client.listTeams();
+    const requestedTeamId = options.teamId ?? (options.useDefaults ? this.defaultTeamId ?? void 0 : void 0);
+    const requestedTeamKey = normalizeTeamKey(options.teamKey) ?? (options.useDefaults ? this.defaultTeamKey ?? void 0 : void 0);
+    const usingDefaultSelection = options.useDefaults === true && options.teamId === void 0 && options.teamKey === void 0;
+    const byId = requestedTeamId ? teams.find((team2) => team2.id === requestedTeamId) ?? null : null;
+    const byKey = requestedTeamKey ? teams.find((team2) => normalizeTeamKey(team2.key) === requestedTeamKey) ?? null : null;
+    if (requestedTeamId && requestedTeamKey) {
+      const mismatch = !byId || !byKey || byId.id !== byKey.id;
+      if (mismatch) {
+        if (usingDefaultSelection) {
+          throw new ConfigurationError(
+            "LINEAR_DEFAULT_TEAM_ID and LINEAR_DEFAULT_TEAM_KEY do not resolve to the same accessible Linear team.",
+            {
+              requestedTeamId,
+              requestedTeamKey
+            }
+          );
+        }
+        throw new ValidationError("teamId and teamKey must refer to the same Linear team.");
+      }
+    }
+    const team = byId ?? byKey ?? null;
+    if (team) {
+      return {
+        teams,
+        team,
+        warning: null
+      };
+    }
+    const requestedValue = requestedTeamId ?? requestedTeamKey;
+    if (!requestedValue) {
+      return {
+        teams,
+        team: null,
+        warning: null
+      };
+    }
+    if (options.requireResolved || options.strictOnMissing) {
+      throw new ExternalServiceError(`Linear team '${requestedValue}' was not found.`, {
+        statusCode: 404,
+        details: {
+          requestedTeamId,
+          requestedTeamKey
+        }
+      });
+    }
+    return {
+      teams,
+      team: null,
+      warning: usingDefaultSelection ? "The configured default Linear team could not be resolved with the current API token." : `Linear team '${requestedValue}' was not found.`
+    };
+  }
+  async runOperation(operation, work) {
+    try {
+      return await work();
+    } catch (error) {
+      if (error instanceof ConfigurationError || error instanceof ValidationError) {
+        throw error;
+      }
+      if (error instanceof ExternalServiceError) {
+        throw new ExternalServiceError(`Unable to ${operation}. ${error.message}`, {
+          statusCode: error.statusCode,
+          details: error.details,
+          exposeToClient: error.exposeToClient
+        });
+      }
+      const normalized = normalizeError(error);
+      throw new ExternalServiceError(`Unable to ${operation}. ${normalized.message}`, {
+        statusCode: normalized.statusCode,
+        details: normalized.details,
+        exposeToClient: normalized.exposeToClient
+      });
+    }
+  }
+};
+function loadLinearEnvironment(source = process.env) {
+  const env = loadEnv(linearEnvShape, source);
+  const defaultTeamKey = normalizeTeamKey(env.LINEAR_DEFAULT_TEAM_KEY);
+  return {
+    LINEAR_API_KEY: env.LINEAR_API_KEY,
+    LINEAR_API_URL: env.LINEAR_API_URL ?? DEFAULT_LINEAR_API_URL,
+    ...withOptionalProperty("LINEAR_DEFAULT_TEAM_ID", env.LINEAR_DEFAULT_TEAM_ID),
+    ...withOptionalProperty("LINEAR_DEFAULT_TEAM_KEY", defaultTeamKey),
+    ...withOptionalProperty("LINEAR_WORKSPACE_NAME", env.LINEAR_WORKSPACE_NAME)
+  };
+}
+async function createServer(options = {}) {
+  const environment = options.environment ?? loadLinearEnvironment();
+  const client = options.client ?? new LinearApiClient({
+    apiKey: environment.LINEAR_API_KEY,
+    apiUrl: environment.LINEAR_API_URL,
+    ...withOptionalProperty("fetchFn", options.fetchFn)
+  });
+  return new LinearServer({
+    client,
+    defaultTeamId: environment.LINEAR_DEFAULT_TEAM_ID ?? null,
+    defaultTeamKey: environment.LINEAR_DEFAULT_TEAM_KEY ?? null,
+    workspaceName: environment.LINEAR_WORKSPACE_NAME ?? null
+  });
+}
+var runtimeRegistration = {
+  createServer: () => createServer(),
+  serverCard
+};
+async function main() {
+  const runtimeOptions = parseRuntimeOptions();
+  await runToolkitServer(runtimeRegistration, runtimeOptions);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  void main().catch((error) => {
+    const normalized = normalizeError(error);
+    console.error(normalized.toClientMessage());
+    process.exitCode = 1;
+  });
+}
+export {
+  LinearApiClient,
+  LinearServer,
+  PROMPT_NAMES,
+  RESOURCE_NAMES,
+  TEAM_RESOURCE_URI,
+  TOOL_NAMES,
+  createIssueInputShape,
+  createIssueOutputShape,
+  createServer,
+  getIssueInputShape,
+  getIssueOutputShape,
+  loadLinearEnvironment,
+  main,
+  metadata,
+  searchIssuesInputShape,
+  searchIssuesOutputShape,
+  serverCard,
+  sprintTriagePromptArgsShape
+};