@sentry/junior-linear 0.120.0 → 0.122.0

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.
+Issue creation uses a Junior-owned tool backed by Linear's hosted MCP connection. This lets Junior link created issues to the conversation while keeping Linear's existing OAuth flow. Other Linear operations continue to use the hosted MCP tools.
 
 Optional: set channel defaults when a Slack thread usually routes work to the same Linear destination:
 

package/dist/index.js

@@ -6,12 +6,9 @@ import {
 // 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."),
@@ -30,27 +27,10 @@ var outputSchema = pluginToolResultSchema.extend({
   status: z.literal("success"),
   target: z.literal("createIssue"),
   data: z.object({
-    issue: issueSchema.nullable(),
-    providerText: z.string()
+    issue: issueSchema.nullable()
   }),
-  issue: issueSchema.nullable(),
-  providerText: z.string()
+  issue: issueSchema.nullable()
 });
-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") {
     return;
@@ -70,11 +50,6 @@ function stringField(objects, field) {
   }
   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);
@@ -83,14 +58,20 @@ function parseJsonText(text) {
   }
 }
 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 textParts = result.content.flatMap(
+    (part) => part.type === "text" ? [part.text] : []
   );
-  const identifierMatch = text.match(/\b[A-Z][A-Z0-9]*-\d+\b/);
+  for (const text of textParts) {
+    collectObjects(parseJsonText(text), objects);
+  }
+  const urlMatch = textParts.map(
+    (text) => text.match(
+      /https:\/\/linear\.app\/[^\s<>)"']+\/issue\/([A-Z][A-Z0-9]*-\d+)[^\s<>)"']*/i
+    )
+  ).find((match) => match !== null);
+  const identifierMatch = textParts.map((text) => text.match(/\b[A-Z][A-Z0-9]*-\d+\b/)).find((match) => match !== null);
   const issue = {
     id: stringField(objects, "id"),
     identifier: stringField(objects, "identifier") ?? urlMatch?.[1]?.toUpperCase() ?? identifierMatch?.[0],
@@ -107,16 +88,22 @@ function extractIssue(result) {
   }
   return parsed.data;
 }
-function toolResult(issue, text) {
-  const data = { issue, providerText: text };
+function toolResult(issue, content) {
+  const data = { issue };
   return {
-    ok: true,
-    status: "success",
-    target: "createIssue",
-    data,
-    ...data
+    content,
+    details: {
+      ok: true,
+      status: "success",
+      target: "createIssue",
+      data,
+      ...data
+    }
   };
 }
+function authorizationPendingResult() {
+  return toolResult(null, [{ type: "text", text: "Authorization pending." }]);
+}
 async function annotateIssue(ctx, issue) {
   if (!issue?.identifier || !issue.url) {
     return;
@@ -129,10 +116,6 @@ async function annotateIssue(ctx, issue) {
     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.",
@@ -140,7 +123,7 @@ function createLinearIssueTool(ctx) {
     outputSchema,
     annotations: {
       destructiveHint: false,
-      idempotentHint: true,
+      idempotentHint: false,
       openWorldHint: true,
       readOnlyHint: false,
       title: "Create Linear issue"
@@ -153,64 +136,106 @@ function createLinearIssueTool(ctx) {
       if (!mcp) {
         throw new Error("Linear MCP provider is unavailable.");
       }
-      const conversationId = required(ctx.conversationId, "conversationId");
-      const toolCallId = required(options.toolCallId, "toolCallId");
+      const result = await mcp.callTool({
+        name: "save_issue",
+        arguments: input,
+        toolCallId: options.toolCallId
+      });
+      if (result.status === "authorization_pending") {
+        return authorizationPendingResult();
+      }
+      if (result.status === "error") {
+        throw new Error(result.message);
+      }
+      const issue = extractIssue(result);
+      await annotateIssue(ctx, issue);
+      return toolResult(issue, result.content);
+    }
+  });
+}
+
+// src/tools/update-issue.ts
+import {
+  definePluginTool as definePluginTool2,
+  pluginToolResultSchema as pluginToolResultSchema2
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var nullableName = (description) => z2.string().trim().min(1).nullable().describe(description).optional();
+var inputSchema2 = z2.object({
+  id: z2.string().trim().min(1).describe("Linear issue identifier or ID to update."),
+  assignee: nullableName(
+    'Assignee name, email, identifier, or "me". Use null to clear.'
+  ),
+  cycle: nullableName("Cycle name or identifier. Use null to clear."),
+  description: z2.string().nullable().describe("Issue description. Use null to clear.").optional(),
+  estimate: z2.number().nonnegative().nullable().describe("Issue estimate. Use null to clear.").optional(),
+  labels: z2.array(z2.string().trim().min(1)).describe("Complete set of issue label names or identifiers.").optional(),
+  priority: z2.enum(["low", "medium", "high", "urgent"]).nullable().describe("Linear priority. Use null to clear.").optional(),
+  project: nullableName("Project name or identifier. Use null to clear."),
+  state: z2.string().trim().min(1).describe("Workflow state name or identifier.").optional(),
+  team: z2.string().trim().min(1).describe("Team name or identifier.").optional(),
+  title: z2.string().trim().min(1).max(60).describe("Issue title.").optional()
+}).strict().superRefine((input, ctx) => {
+  if (Object.keys(input).every((key) => key === "id")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "At least one issue field must be provided."
+    });
+  }
+});
+var outputSchema2 = pluginToolResultSchema2.extend({
+  ok: z2.literal(true),
+  status: z2.literal("success"),
+  target: z2.literal("updateIssue")
+});
+function toolResult2(content) {
+  return {
+    content,
+    details: {
+      ok: true,
+      status: "success",
+      target: "updateIssue"
+    }
+  };
+}
+function authorizationPendingResult2() {
+  return toolResult2([{ type: "text", text: "Authorization pending." }]);
+}
+function createLinearUpdateIssueTool(ctx) {
+  return definePluginTool2({
+    description: "Update an existing Linear issue through Linear's hosted MCP provider. Fetch the issue first when a change could overwrite existing fields.",
+    inputSchema: inputSchema2,
+    outputSchema: outputSchema2,
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false,
+      title: "Update Linear issue"
+    },
+    describeProposal(input) {
+      return `Update Linear issue ${input.id}`;
+    },
+    async execute(input, options) {
+      const mcp = ctx.mcp;
+      if (!mcp) {
+        throw new Error("Linear MCP provider is unavailable.");
+      }
       if (await mcp.prepare() === "authorization_pending") {
-        return toolResult(null, "Authorization pending.");
+        return authorizationPendingResult2();
+      }
+      const result = await mcp.callTool({
+        name: "save_issue",
+        arguments: input,
+        toolCallId: options.toolCallId
+      });
+      if (result.status === "authorization_pending") {
+        return authorizationPendingResult2();
+      }
+      if (result.status === "error") {
+        throw new Error(result.message);
       }
-      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);
-        }
-      );
+      return toolResult2(result.content);
     }
   });
 }
@@ -226,14 +251,15 @@ function linearPlugin() {
       mcp: {
         transport: "http",
         url: "https://mcp.linear.app/mcp",
-        wrappedTools: ["create_issue"]
+        wrappedTools: ["save_issue"]
       },
       name: "linear"
     },
     hooks: {
       tools(ctx) {
         return {
-          createIssue: createLinearIssueTool(ctx)
+          createIssue: createLinearIssueTool(ctx),
+          updateIssue: createLinearUpdateIssueTool(ctx)
         };
       }
     }

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

@@ -1,4 +1,4 @@
-import { type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+import { type PluginToolResultEnvelope, 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;
@@ -18,7 +18,6 @@ export declare function createLinearIssueTool(ctx: ToolRegistrationHookContext):
             title?: string | undefined;
             url?: string | undefined;
         } | null;
-        providerText: string;
     };
     issue: {
         id?: string | undefined;
@@ -26,7 +25,6 @@ export declare function createLinearIssueTool(ctx: ToolRegistrationHookContext):
         title?: string | undefined;
         url?: string | undefined;
     } | null;
-    providerText: string;
     truncated?: boolean | undefined;
     continuation?: {
         arguments: Record<string, unknown>;
@@ -37,4 +35,33 @@ export declare function createLinearIssueTool(ctx: ToolRegistrationHookContext):
         message: string;
         retryable?: boolean | undefined;
     } | undefined;
-}>;
+}, PluginToolResultEnvelope<{
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: "createIssue";
+    data: {
+        issue: {
+            id?: string | undefined;
+            identifier?: string | undefined;
+            title?: string | undefined;
+            url?: string | undefined;
+        } | null;
+    };
+    issue: {
+        id?: string | undefined;
+        identifier?: string | undefined;
+        title?: string | undefined;
+        url?: string | undefined;
+    } | null;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>>;

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

@@ -0,0 +1,47 @@
+import { type PluginToolResultEnvelope, type ToolRegistrationHookContext } from "@sentry/junior-plugin-api";
+/** Update a Linear issue through the hosted MCP provider. */
+export declare function createLinearUpdateIssueTool(ctx: ToolRegistrationHookContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    id: string;
+    assignee?: string | null | undefined;
+    cycle?: string | null | undefined;
+    description?: string | null | undefined;
+    estimate?: number | null | undefined;
+    labels?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | "urgent" | null | undefined;
+    project?: string | null | undefined;
+    state?: string | undefined;
+    team?: string | undefined;
+    title?: string | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: "updateIssue";
+    data?: unknown;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}, PluginToolResultEnvelope<{
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: "updateIssue";
+    data?: unknown;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
+}>>;

package/package.json

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

package/skills/linear/SKILL.md

@@ -68,6 +68,7 @@ If any gate fails, revise and re-check before calling the Linear create/update t
 6. Execute:
 
 - Create new issues with `linear_createIssue`.
+- Update existing issues with `linear_updateIssue`.
 - 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.