@striderlabs/mcp-linear 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+var API_KEY = process.env.LINEAR_API_KEY;
+var GRAPHQL_URL = "https://api.linear.app/graphql";
+async function linearQuery(query, variables) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (API_KEY) {
+    headers["Authorization"] = API_KEY;
+  }
+  const res = await fetch(GRAPHQL_URL, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query, variables })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Linear API error ${res.status}: ${JSON.stringify(data)}`);
+  }
+  if (data.errors) {
+    throw new Error(`Linear GraphQL errors: ${JSON.stringify(data.errors)}`);
+  }
+  return data.data;
+}
+var server = new Server(
+  { name: "mcp-linear", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "list_issues",
+      description: "List Linear issues",
+      inputSchema: {
+        type: "object",
+        properties: {
+          team_id: { type: "string", description: "Filter by team ID" },
+          first: { type: "number", description: "Number of issues to return (default 20)" },
+          state: { type: "string", description: "Filter by state name (e.g. 'In Progress')" },
+          assignee_id: { type: "string", description: "Filter by assignee ID" }
+        }
+      }
+    },
+    {
+      name: "get_issue",
+      description: "Get a Linear issue by ID",
+      inputSchema: {
+        type: "object",
+        properties: {
+          issue_id: { type: "string", description: "The issue ID" }
+        },
+        required: ["issue_id"]
+      }
+    },
+    {
+      name: "create_issue",
+      description: "Create a new Linear issue",
+      inputSchema: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Issue title" },
+          description: { type: "string", description: "Issue description (markdown)" },
+          team_id: { type: "string", description: "Team ID" },
+          assignee_id: { type: "string", description: "Assignee user ID" },
+          priority: { type: "number", description: "Priority 0-4 (0=no priority, 1=urgent, 2=high, 3=medium, 4=low)" },
+          state_id: { type: "string", description: "Workflow state ID" },
+          label_ids: { type: "array", items: { type: "string" }, description: "Label IDs" }
+        },
+        required: ["title", "team_id"]
+      }
+    },
+    {
+      name: "update_issue",
+      description: "Update a Linear issue",
+      inputSchema: {
+        type: "object",
+        properties: {
+          issue_id: { type: "string", description: "The issue ID" },
+          title: { type: "string", description: "New title" },
+          description: { type: "string", description: "New description" },
+          state_id: { type: "string", description: "New state ID" },
+          assignee_id: { type: "string", description: "New assignee ID" },
+          priority: { type: "number", description: "New priority (0-4)" }
+        },
+        required: ["issue_id"]
+      }
+    },
+    {
+      name: "list_projects",
+      description: "List Linear projects",
+      inputSchema: {
+        type: "object",
+        properties: {
+          team_id: { type: "string", description: "Filter by team ID" },
+          first: { type: "number", description: "Number of projects to return" }
+        }
+      }
+    },
+    {
+      name: "search_issues",
+      description: "Search Linear issues by text",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          first: { type: "number", description: "Number of results" }
+        },
+        required: ["query"]
+      }
+    }
+  ]
+}));
+var ListIssuesSchema = z.object({
+  team_id: z.string().optional(),
+  first: z.number().optional(),
+  state: z.string().optional(),
+  assignee_id: z.string().optional()
+});
+var GetIssueSchema = z.object({ issue_id: z.string() });
+var CreateIssueSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  team_id: z.string(),
+  assignee_id: z.string().optional(),
+  priority: z.number().optional(),
+  state_id: z.string().optional(),
+  label_ids: z.array(z.string()).optional()
+});
+var UpdateIssueSchema = z.object({
+  issue_id: z.string(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  state_id: z.string().optional(),
+  assignee_id: z.string().optional(),
+  priority: z.number().optional()
+});
+var ListProjectsSchema = z.object({
+  team_id: z.string().optional(),
+  first: z.number().optional()
+});
+var SearchIssuesSchema = z.object({
+  query: z.string(),
+  first: z.number().optional()
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "list_issues": {
+        const params = ListIssuesSchema.parse(args);
+        const filter = {};
+        if (params.team_id) filter.team = { id: { eq: params.team_id } };
+        if (params.state) filter.state = { name: { eq: params.state } };
+        if (params.assignee_id) filter.assignee = { id: { eq: params.assignee_id } };
+        const query = `
+          query ListIssues($first: Int, $filter: IssueFilter) {
+            issues(first: $first, filter: $filter) {
+              nodes {
+                id
+                title
+                description
+                priority
+                state { id name }
+                assignee { id name email }
+                team { id name }
+                createdAt
+                updatedAt
+              }
+            }
+          }
+        `;
+        const result = await linearQuery(query, {
+          first: params.first ?? 20,
+          filter: Object.keys(filter).length > 0 ? filter : void 0
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_issue": {
+        const { issue_id } = GetIssueSchema.parse(args);
+        const query = `
+          query GetIssue($id: String!) {
+            issue(id: $id) {
+              id
+              title
+              description
+              priority
+              state { id name }
+              assignee { id name email }
+              team { id name }
+              labels { nodes { id name } }
+              comments { nodes { id body createdAt user { name } } }
+              createdAt
+              updatedAt
+            }
+          }
+        `;
+        const result = await linearQuery(query, { id: issue_id });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "create_issue": {
+        const params = CreateIssueSchema.parse(args);
+        const mutation = `
+          mutation CreateIssue($input: IssueCreateInput!) {
+            issueCreate(input: $input) {
+              success
+              issue {
+                id
+                title
+                state { name }
+                team { name }
+              }
+            }
+          }
+        `;
+        const input = {
+          title: params.title,
+          teamId: params.team_id
+        };
+        if (params.description) input.description = params.description;
+        if (params.assignee_id) input.assigneeId = params.assignee_id;
+        if (params.priority !== void 0) input.priority = params.priority;
+        if (params.state_id) input.stateId = params.state_id;
+        if (params.label_ids) input.labelIds = params.label_ids;
+        const result = await linearQuery(mutation, { input });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "update_issue": {
+        const { issue_id, ...updates } = UpdateIssueSchema.parse(args);
+        const mutation = `
+          mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+            issueUpdate(id: $id, input: $input) {
+              success
+              issue {
+                id
+                title
+                state { name }
+              }
+            }
+          }
+        `;
+        const input = {};
+        if (updates.title) input.title = updates.title;
+        if (updates.description) input.description = updates.description;
+        if (updates.state_id) input.stateId = updates.state_id;
+        if (updates.assignee_id) input.assigneeId = updates.assignee_id;
+        if (updates.priority !== void 0) input.priority = updates.priority;
+        const result = await linearQuery(mutation, { id: issue_id, input });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "list_projects": {
+        const params = ListProjectsSchema.parse(args);
+        const filter = {};
+        if (params.team_id) filter.accessibleTeams = { some: { id: { eq: params.team_id } } };
+        const query = `
+          query ListProjects($first: Int, $filter: ProjectFilter) {
+            projects(first: $first, filter: $filter) {
+              nodes {
+                id
+                name
+                description
+                state
+                startDate
+                targetDate
+                teams { nodes { id name } }
+              }
+            }
+          }
+        `;
+        const result = await linearQuery(query, {
+          first: params.first ?? 20,
+          filter: Object.keys(filter).length > 0 ? filter : void 0
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "search_issues": {
+        const { query: searchQuery, first } = SearchIssuesSchema.parse(args);
+        const query = `
+          query SearchIssues($query: String!, $first: Int) {
+            issueSearch(query: $query, first: $first) {
+              nodes {
+                id
+                title
+                description
+                priority
+                state { name }
+                assignee { name }
+                team { name }
+              }
+            }
+          }
+        `;
+        const result = await linearQuery(query, { query: searchQuery, first: first ?? 20 });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@striderlabs/mcp-linear",
+  "version": "1.0.0",
+  "description": "MCP connector for Linear GraphQL API",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-linear": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "tsup": "latest",
+    "typescript": "latest",
+    "@types/node": "latest"
+  }
+}