@sentry/junior-linear 0.121.0 → 0.122.1

package/README.md

@@ -19,7 +19,7 @@ export const plugins = defineJuniorPlugins([linearPlugin()]);
 
 This package does not require a shared `LINEAR_API_KEY` or a custom OAuth app for the default setup. Each user connects their own Linear account the first time Junior calls a Linear MCP tool. Junior sends the authorization link privately and resumes the same Slack thread automatically after the user authorizes.
 
-Issue creation uses a Junior-owned tool backed by Linear's hosted MCP connection. This lets Junior prevent duplicate retries and link created issues to the conversation while keeping Linear's existing OAuth flow. Other Linear operations continue to use the hosted MCP tools.
+Linear operations use Linear's hosted MCP tools directly. When an issue is created through that path, Junior links it to the current conversation.
 
 Optional: set channel defaults when a Slack thread usually routes work to the same Linear destination:
 

package/dist/index.js

@@ -2,220 +2,36 @@
 import {
   defineJuniorPlugin
 } from "@sentry/junior-plugin-api";
-
-// src/tools/create-issue.ts
-import {
-  definePluginTool,
-  PluginToolInputError,
-  pluginToolResultSchema
-} from "@sentry/junior-plugin-api";
 import { z } from "zod";
-var CREATE_ISSUE_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var CREATE_ISSUE_LOCK_TTL_MS = 6e4;
-var inputSchema = z.object({
-  team: z.string().trim().min(1).describe("Linear team name or identifier."),
-  title: z.string().trim().min(1).max(60).describe("Issue title."),
-  description: z.string().describe("Issue description.").optional(),
-  priority: z.enum(["low", "medium", "high", "urgent"]).describe("Linear priority.").optional(),
-  project: z.string().trim().min(1).describe("Linear project name or identifier.").optional()
-}).strict();
-var issueSchema = z.object({
-  id: z.string().optional(),
-  identifier: z.string().optional(),
-  title: z.string().optional(),
-  url: z.string().url().optional()
-}).strict();
-var outputSchema = pluginToolResultSchema.extend({
-  ok: z.literal(true),
-  status: z.literal("success"),
-  target: z.literal("createIssue"),
-  data: z.object({
-    issue: issueSchema.nullable(),
-    providerText: z.string()
-  }),
-  issue: issueSchema.nullable(),
-  providerText: z.string()
-});
-var completedStateSchema = z.object({
-  createdAtMs: z.number(),
-  issue: issueSchema.nullable(),
-  providerText: z.string(),
-  status: z.literal("completed")
-}).strict();
-var pendingStateSchema = z.object({
-  createdAtMs: z.number(),
-  status: z.literal("pending")
-}).strict();
-var stateSchema = z.union([completedStateSchema, pendingStateSchema]);
-function parseState(value) {
-  const parsed = stateSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-function collectObjects(value, objects) {
-  if (!value || typeof value !== "object") {
+var saveIssueResultSchema = z.object({
+  issue: z.object({
+    identifier: z.string().trim().min(1),
+    url: z.url()
+  }).passthrough()
+}).passthrough();
+async function annotateCreatedIssue(ctx) {
+  if (ctx.tool.name !== "save_issue" || ctx.tool.arguments.id !== void 0) {
     return;
   }
-  if (Array.isArray(value)) {
-    for (const item of value) collectObjects(item, objects);
+  if (!ctx.annotations) {
     return;
   }
-  const record = value;
-  objects.push(record);
-  for (const item of Object.values(record)) collectObjects(item, objects);
-}
-function stringField(objects, field) {
-  for (const object of objects) {
-    const value = object[field];
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return void 0;
-}
-function providerText(result) {
-  return result.content.filter(
-    (part) => part.type === "text"
-  ).map((part) => part.text).join("\n\n").trim();
-}
-function parseJsonText(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-function extractIssue(result) {
-  const text = providerText(result);
-  const objects = [];
-  collectObjects(result.structuredContent, objects);
-  collectObjects(parseJsonText(text), objects);
-  const urlMatch = text.match(
-    /https:\/\/linear\.app\/[^\s<>)"']+\/issue\/([A-Z][A-Z0-9]*-\d+)[^\s<>)"']*/i
-  );
-  const identifierMatch = text.match(/\b[A-Z][A-Z0-9]*-\d+\b/);
-  const issue = {
-    id: stringField(objects, "id"),
-    identifier: stringField(objects, "identifier") ?? urlMatch?.[1]?.toUpperCase() ?? identifierMatch?.[0],
-    title: stringField(objects, "title"),
-    url: stringField(objects, "url") ?? urlMatch?.[0]
-  };
-  const parsed = issueSchema.safeParse(
-    Object.fromEntries(
-      Object.entries(issue).filter((entry) => entry[1] !== void 0)
-    )
-  );
-  if (!parsed.success || Object.keys(parsed.data).length === 0) {
-    return null;
-  }
-  return parsed.data;
-}
-function toolResult(issue, text) {
-  const data = { issue, providerText: text };
-  return {
-    ok: true,
-    status: "success",
-    target: "createIssue",
-    data,
-    ...data
-  };
-}
-async function annotateIssue(ctx, issue) {
-  if (!issue?.identifier || !issue.url) {
+  const result = saveIssueResultSchema.safeParse(ctx.result.structuredContent);
+  if (!result.success) {
+    ctx.log.warn("linear.issue_annotation.skipped", {
+      "app.reason": "unexpected_save_response"
+    });
     return;
   }
-  await ctx.annotations?.upsert({
+  const identifier = result.data.issue.identifier.toUpperCase();
+  await ctx.annotations.upsert({
     kind: "resource_link",
-    key: issue.identifier.toUpperCase(),
-    label: issue.identifier.toUpperCase(),
-    url: issue.url,
+    key: identifier,
+    label: identifier,
+    url: result.data.issue.url,
     status: "open"
   });
 }
-function required(value, name) {
-  if (!value?.trim()) throw new PluginToolInputError(`${name} is required`);
-  return value.trim();
-}
-function createLinearIssueTool(ctx) {
-  return definePluginTool({
-    description: "Create a Linear issue through Linear's hosted MCP provider and link the created issue to the current Junior conversation.",
-    inputSchema,
-    outputSchema,
-    annotations: {
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: true,
-      readOnlyHint: false,
-      title: "Create Linear issue"
-    },
-    describeProposal(input) {
-      return `Create a Linear issue in ${input.team}: ${input.title}`;
-    },
-    async execute(input, options) {
-      const mcp = ctx.mcp;
-      if (!mcp) {
-        throw new Error("Linear MCP provider is unavailable.");
-      }
-      const conversationId = required(ctx.conversationId, "conversationId");
-      const toolCallId = required(options.toolCallId, "toolCallId");
-      if (await mcp.prepare() === "authorization_pending") {
-        return toolResult(null, "Authorization pending.");
-      }
-      const key = `createIssue:${conversationId}:${toolCallId}`;
-      return await ctx.state.withLock(
-        `${key}:lock`,
-        CREATE_ISSUE_LOCK_TTL_MS,
-        async () => {
-          const state = parseState(await ctx.state.get(key));
-          if (state?.status === "completed") {
-            await annotateIssue(ctx, state.issue);
-            return toolResult(state.issue, state.providerText);
-          }
-          if (state?.status === "pending") {
-            throw new Error(
-              "Linear issue creation for this tool call has an uncertain pending result; refusing to create a duplicate issue."
-            );
-          }
-          await ctx.state.set(
-            key,
-            { status: "pending", createdAtMs: Date.now() },
-            CREATE_ISSUE_STATE_TTL_MS
-          );
-          const result = await mcp.callTool({
-            name: "create_issue",
-            arguments: input,
-            toolCallId
-          });
-          if (result.status === "authorization_pending") {
-            await ctx.state.delete(key);
-            return toolResult(null, "Authorization pending.");
-          }
-          if (result.status === "error") {
-            await ctx.state.delete(key);
-            throw new Error(result.message);
-          }
-          const text = providerText(result);
-          const issue = extractIssue(result);
-          const completedState = {
-            status: "completed",
-            createdAtMs: Date.now(),
-            issue,
-            providerText: text
-          };
-          try {
-            await ctx.state.set(key, completedState, CREATE_ISSUE_STATE_TTL_MS);
-          } catch (error) {
-            throw new Error(
-              "Linear issue was created, but Junior could not persist the completed issue state.",
-              { cause: error }
-            );
-          }
-          await annotateIssue(ctx, issue);
-          return toolResult(issue, text);
-        }
-      );
-    }
-  });
-}
-
-// src/plugin.ts
 function linearPlugin() {
   return defineJuniorPlugin({
     packageName: "@sentry/junior-linear",
@@ -225,17 +41,12 @@ function linearPlugin() {
       displayName: "Linear",
       mcp: {
         transport: "http",
-        url: "https://mcp.linear.app/mcp",
-        wrappedTools: ["create_issue"]
+        url: "https://mcp.linear.app/mcp"
       },
       name: "linear"
     },
     hooks: {
-      tools(ctx) {
-        return {
-          createIssue: createLinearIssueTool(ctx)
-        };
-      }
+      afterMcpTool: annotateCreatedIssue
     }
   });
 }

package/dist/plugin.d.ts

@@ -1,3 +1,3 @@
 import { type PluginRegistration } from "@sentry/junior-plugin-api";
-/** Register Linear's hosted MCP provider and Junior-owned wrapper tools. */
+/** Register Linear's hosted MCP provider and conversation-link side effects. */
 export declare function linearPlugin(): PluginRegistration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-linear",
-  "version": "0.121.0",
+  "version": "0.122.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.121.0"
+    "@sentry/junior-plugin-api": "0.122.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/skills/linear/SKILL.md

@@ -67,7 +67,7 @@ If any gate fails, revise and re-check before calling the Linear create/update t
 
 6. Execute:
 
-- Create new issues with `linear_createIssue`.
+- Create or update issues with Linear's live hosted MCP tools. Discover the current create/update tool and copy only fields justified by its live schema.
 - For updates, prefer partial changes over full rewrites. Fetch current issue state first if the mutation could overwrite structured fields or duplicate an existing comment.
 - Check for duplicates silently before creating a new issue when the request appears related to existing work.
 

package/skills/linear/references/api-surface.md

@@ -21,8 +21,8 @@ The current public docs describe support for finding, creating, and updating obj
 | Intent               | Minimum tool pattern                                                                                                         |
 | -------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
 | Inspect an issue     | Resolve the issue by key, URL, or search query, then fetch current state before answering.                                   |
-| Create an issue      | Confirm the team first, then create the issue with grounded title/body content and only the optional fields you can justify. |
-| Update fields        | Fetch current issue state first, then mutate only the requested fields.                                                      |
+| Create an issue      | Confirm the team first, then create via the live hosted MCP tools with grounded title/body content and only fields justified by the current schema. |
+| Update fields        | Fetch current issue state first, then mutate via the live hosted MCP tools with only the requested fields.                                                      |
 | Add a comment        | Resolve the exact issue first, then add a concise comment with durable links and next steps.                                 |
 | Move state or assign | Read the current issue and team workflow first when state, workflow, or assignee ambiguity could cause the wrong mutation.   |
 | Check for duplicates | Search for an existing matching issue before opening a new one when the request appears related to ongoing work.             |

package/dist/tools/create-issue.d.ts

@@ -1,40 +0,0 @@
-import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
-/** Create a Linear issue through the hosted MCP provider and link it to the conversation. */
-export declare function createLinearIssueTool(ctx: ToolRegistrationHookContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
-    team: string;
-    title: string;
-    description?: string | undefined;
-    priority?: "low" | "medium" | "high" | "urgent" | undefined;
-    project?: string | undefined;
-}, {
-    [x: string]: unknown;
-    ok: true;
-    status: "success";
-    target: "createIssue";
-    data: {
-        issue: {
-            id?: string | undefined;
-            identifier?: string | undefined;
-            title?: string | undefined;
-            url?: string | undefined;
-        } | null;
-        providerText: string;
-    };
-    issue: {
-        id?: string | undefined;
-        identifier?: string | undefined;
-        title?: string | undefined;
-        url?: string | undefined;
-    } | null;
-    providerText: string;
-    truncated?: boolean | undefined;
-    continuation?: {
-        arguments: Record<string, unknown>;
-        reason?: string | undefined;
-    } | undefined;
-    error?: string | {
-        kind: string;
-        message: string;
-        retryable?: boolean | undefined;
-    } | undefined;
-}>;