runline 0.8.0 → 0.9.0

package/dist/plugins/linear/src/initiatives.js

@@ -0,0 +1,84 @@
+import * as t from "typebox";
+import { INITIATIVE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+export function registerInitiativeActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("initiative.list", "List initiatives.", "initiatives", "InitiativeFilter", INITIATIVE_FIELDS);
+    getAction("initiative.get", "Get an initiative by ID or slug.", "initiative", INITIATIVE_FIELDS);
+    rl.registerAction("initiative.create", {
+        description: "Create an initiative. Status: Planned | Active | Completed.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the initiative" }),
+            description: t.Optional(t.String({ description: "The description of the initiative" })),
+            content: t.Optional(t.String({ description: "The initiative's content in markdown format" })),
+            icon: t.Optional(t.String({ description: "The initiative's icon" })),
+            color: t.Optional(t.String({ description: "The initiative's color (hex)" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the initiative" })),
+            status: t.Optional(t.String({ description: "The initiative's status (InitiativeStatus: Planned | Active | Completed)" })),
+            targetDate: t.Optional(t.String({ description: "The estimated completion date of the initiative (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the initiative's estimated completion date (DateResolutionType)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order of the initiative within the workspace (Float)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "initiatives.*");
+            const data = await gql(key(ctx), `mutation($input: InitiativeCreateInput!) { initiativeCreate(input: $input) { success initiative { ${INITIATIVE_FIELDS} } } }`, { input: input });
+            return data.initiativeCreate?.initiative;
+        },
+    });
+    rl.registerAction("initiative.update", {
+        description: "Update an initiative.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the initiative to update" }),
+            name: t.Optional(t.String({ description: "The name of the initiative" })),
+            description: t.Optional(t.String({ description: "The description of the initiative" })),
+            content: t.Optional(t.String({ description: "The initiative's content in markdown format" })),
+            icon: t.Optional(t.String({ description: "The initiative's icon" })),
+            color: t.Optional(t.String({ description: "The initiative's color (hex)" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the initiative" })),
+            status: t.Optional(t.String({ description: "The initiative's status (InitiativeStatus: Planned | Active | Completed)" })),
+            targetDate: t.Optional(t.String({ description: "The estimated completion date (TimelessDate, YYYY-MM-DD). Set to null to clear" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the initiative's estimated completion date (DateResolutionType)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order of the initiative within the workspace (Float)" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the initiative has been trashed. Set to true to trash, or null to restore" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "initiatives.*");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: InitiativeUpdateInput!) { initiativeUpdate(id: $id, input: $input) { success initiative { ${INITIATIVE_FIELDS} } } }`, { id, input: fields });
+            return data.initiativeUpdate?.initiative;
+        },
+    });
+    rl.registerAction("initiative.delete", {
+        description: "Trash an initiative.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiative to delete" }) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "initiatives.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { initiativeDelete(id: $id) { success } }`, { id: input.id });
+            return data.initiativeDelete;
+        },
+    });
+    rl.registerAction("initiative.addProject", {
+        description: "Associate a project with an initiative. Use this action for project-to-initiative linking; project.update does not accept initiativeId. Verify with initiative.get or the returned initiative.projects list.",
+        inputSchema: t.Object({
+            initiativeId: t.String({ description: "The identifier of the initiative" }),
+            projectId: t.String({ description: "The identifier of the project" }),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project within the initiative (Float)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "initiatives.*");
+            const data = await gql(key(ctx), `mutation($input: InitiativeToProjectCreateInput!) { initiativeToProjectCreate(input: $input) { success initiativeToProject { id initiative { id name projects { nodes { id name } } } project { id name } } } }`, { input: input });
+            return data.initiativeToProjectCreate;
+        },
+    });
+    rl.registerAction("initiative.removeProject", {
+        description: "Remove a project from an initiative. Pass the link id returned by initiative.addProject, then verify with initiative.get.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the initiativeToProject to delete" }) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "initiatives.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { initiativeToProjectDelete(id: $id) { success } }`, { id: input.id });
+            return data.initiativeToProjectDelete;
+        },
+    });
+}

package/dist/plugins/linear/src/issues.js

@@ -0,0 +1,267 @@
+import * as t from "typebox";
+import { COMMENT_FIELDS, ISSUE_FIELDS, ISSUE_LITE, LIST_INPUT_SCHEMA, assertIssueInScope, buildConnArgs, ensureScopeLabelsOnCreateOrReplace, forbidScopeLabelRemoval, gql, issueHasScope, key, mergeIssueScopeFilter, } from "./shared.js";
+export function registerIssueActions(rl) {
+    rl.registerAction("issue.create", {
+        description: "Create an issue. teamId is required; title is required unless a template is applied.",
+        inputSchema: t.Object({
+            teamId: t.String({ description: "The identifier of the team associated with the issue" }),
+            title: t.String({ description: "The title of the issue" }),
+            description: t.Optional(t.String({ description: "The issue description in markdown format" })),
+            assigneeId: t.Optional(t.String({ description: "The identifier of the user to assign the issue to" })),
+            priority: t.Optional(t.Number({ description: "Priority. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            stateId: t.Optional(t.String({ description: "The team workflow state of the issue" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the issue labels associated with this ticket" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent issue. UUID or issue identifier (e.g., 'LIN-123')" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the issue" })),
+            projectMilestoneId: t.Optional(t.String({ description: "The project milestone associated with the issue" })),
+            cycleId: t.Optional(t.String({ description: "The cycle associated with the issue" })),
+            estimate: t.Optional(t.Number({ description: "The estimated complexity of the issue (Int)" })),
+            dueDate: t.Optional(t.String({ description: "The date at which the issue is due (TimelessDate, YYYY-MM-DD)" })),
+            subscriberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the users subscribing to this ticket" })),
+            templateId: t.Optional(t.String({ description: "The identifier of a template the issue should be created from" })),
+            useDefaultTemplate: t.Optional(t.Boolean({ description: "Apply the team's default template based on the user's membership" })),
+            sortOrder: t.Optional(t.Number({ description: "The position of the issue related to other issues (Float)" })),
+            subIssueSortOrder: t.Optional(t.Number({ description: "The position of the issue in its parent's sub-issue list (Float)" })),
+            releaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the releases to associate with this issue" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const fields = { ...input };
+            fields.labelIds = ensureScopeLabelsOnCreateOrReplace(ctx, fields.labelIds);
+            const data = await gql(key(ctx), `mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { input: fields });
+            return data.issueCreate?.issue;
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get an issue by ID or identifier (e.g. 'THE-154')",
+        inputSchema: t.Object({ issueId: t.String() }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `query($id: String!) { issue(id: $id) { ${ISSUE_FIELDS} } }`, { id: input.issueId });
+            const issue = data.issue;
+            if (!issueHasScope(ctx, issue))
+                throw new Error("Linear issue is not available to this scoped connection");
+            return issue;
+        },
+    });
+    rl.registerAction("issue.list", {
+        description: "List issues. Pass `filter` for state/label/project/etc. Default hides archived.",
+        inputSchema: t.Object({
+            ...LIST_INPUT_SCHEMA,
+            teamId: t.Optional(t.String({ description: "Convenience: filter by team" })),
+            assigneeId: t.Optional(t.String({ description: "Convenience: filter by assignee" })),
+        }),
+        async execute(input, ctx) {
+            const opts = (input ?? {});
+            // Merge convenience filters into `filter`
+            const merged = { ...(opts.filter ?? {}) };
+            if (opts.teamId)
+                merged.team = { id: { eq: opts.teamId } };
+            if (opts.assigneeId)
+                merged.assignee = { id: { eq: opts.assigneeId } };
+            const filter = mergeIssueScopeFilter(ctx, Object.keys(merged).length > 0 ? merged : undefined);
+            const { argsDecl, argsCall, vars } = buildConnArgs({ ...opts, filter }, "IssueFilter");
+            const data = await gql(key(ctx), `query${argsDecl} { issues${argsCall} { nodes { ${ISSUE_LITE} } pageInfo { hasNextPage endCursor } } }`, vars);
+            const conn = data.issues;
+            return { nodes: conn.nodes, pageInfo: conn.pageInfo };
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue. All fields optional; only provided fields are updated.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The identifier of the issue to update" }),
+            title: t.Optional(t.String({ description: "The issue title" })),
+            description: t.Optional(t.String({ description: "The issue description in markdown format" })),
+            assigneeId: t.Optional(t.String({ description: "The identifier of the user to assign the issue to" })),
+            stateId: t.Optional(t.String({ description: "The team workflow state of the issue" })),
+            priority: t.Optional(t.Number({ description: "Priority. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the issue labels associated with this ticket (replaces all)" })),
+            addedLabelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of issue labels to be added to this issue" })),
+            removedLabelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of issue labels to be removed from this issue" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the issue" })),
+            projectMilestoneId: t.Optional(t.String({ description: "The project milestone associated with the issue" })),
+            cycleId: t.Optional(t.String({ description: "The cycle associated with the issue" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent issue. UUID or issue identifier (e.g., 'LIN-123')" })),
+            teamId: t.Optional(t.String({ description: "The identifier of the team associated with the issue (move issue to a different team)" })),
+            estimate: t.Optional(t.Number({ description: "The estimated complexity of the issue (Int)" })),
+            dueDate: t.Optional(t.String({ description: "The date at which the issue is due (TimelessDate, YYYY-MM-DD)" })),
+            subscriberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the users subscribing to this ticket" })),
+            sortOrder: t.Optional(t.Number({ description: "The position of the issue related to other issues (Float)" })),
+            subIssueSortOrder: t.Optional(t.Number({ description: "The position of the issue in its parent's sub-issue list (Float)" })),
+            snoozedUntilAt: t.Optional(t.String({ description: "The time until which the issue will be snoozed in Triage view (DateTime)" })),
+            releaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the releases associated with this issue (replaces all)" })),
+            addedReleaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of releases to be added to this issue" })),
+            removedReleaseIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of releases to be removed from this issue" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the issue has been trashed" })),
+        }),
+        async execute(input, ctx) {
+            const { issueId, ...fields } = input;
+            await assertIssueInScope(ctx, String(issueId));
+            if (fields.removedLabelIds)
+                forbidScopeLabelRemoval(ctx, fields.removedLabelIds);
+            if (fields.labelIds)
+                fields.labelIds = ensureScopeLabelsOnCreateOrReplace(ctx, fields.labelIds);
+            const data = await gql(key(ctx), `mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { ${ISSUE_FIELDS} } } }`, { id: issueId, input: fields });
+            return data.issueUpdate?.issue;
+        },
+    });
+    rl.registerAction("issue.delete", {
+        description: "Trash (soft-delete) an issue. Pass permanentlyDelete=true to bypass 30d grace period (admin only).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            permanentlyDelete: t.Optional(t.Boolean()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, permanentlyDelete } = input;
+            await assertIssueInScope(ctx, issueId);
+            const data = await gql(key(ctx), `mutation($id: String!, $perm: Boolean) { issueDelete(id: $id, permanentlyDelete: $perm) { success } }`, { id: issueId, perm: permanentlyDelete ?? null });
+            return data.issueDelete;
+        },
+    });
+    rl.registerAction("issue.archive", {
+        description: "Archive an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            trash: t.Optional(t.Boolean()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, trash } = input;
+            await assertIssueInScope(ctx, issueId);
+            const data = await gql(key(ctx), `mutation($id: String!, $trash: Boolean) { issueArchive(id: $id, trash: $trash) { success } }`, { id: issueId, trash: trash ?? null });
+            return data.issueArchive;
+        },
+    });
+    rl.registerAction("issue.unarchive", {
+        description: "Unarchive an issue.",
+        inputSchema: t.Object({ issueId: t.String() }),
+        async execute(input, ctx) {
+            const issueId = input.issueId;
+            await assertIssueInScope(ctx, issueId);
+            const data = await gql(key(ctx), `mutation($id: String!) { issueUnarchive(id: $id) { success } }`, { id: issueId });
+            return data.issueUnarchive;
+        },
+    });
+    rl.registerAction("issue.search", {
+        description: "Search issues by text query using full-text and vector search. Rate-limited to 30 req/min.",
+        inputSchema: t.Object({
+            term: t.String({ description: "Search string to look for" }),
+            limit: t.Optional(t.Number({ description: "Max results (forward pagination, default 50)" })),
+            filter: t.Optional(t.Object({}, { description: "Optional IssueFilter" })),
+            includeComments: t.Optional(t.Boolean({ description: "Should associated comments be searched (default false)" })),
+            includeArchived: t.Optional(t.Boolean({ description: "Should archived resources be included (default false)" })),
+            teamId: t.Optional(t.String({ description: "UUID of a team to boost in search results" })),
+            orderBy: t.Optional(t.String({ description: "PaginationOrderBy: createdAt | updatedAt" })),
+            after: t.Optional(t.String({ description: "Cursor for forward pagination" })),
+            before: t.Optional(t.String({ description: "Cursor for backward pagination" })),
+        }),
+        async execute(input, ctx) {
+            const opts = input;
+            const data = await gql(key(ctx), `query($term: String!, $first: Int, $filter: IssueFilter, $includeComments: Boolean, $includeArchived: Boolean, $teamId: String, $orderBy: PaginationOrderBy, $after: String, $before: String) {
+          searchIssues(term: $term, first: $first, filter: $filter, includeComments: $includeComments, includeArchived: $includeArchived, teamId: $teamId, orderBy: $orderBy, after: $after, before: $before) {
+            nodes { ${ISSUE_LITE} }
+            totalCount
+            pageInfo { hasNextPage endCursor }
+          }
+        }`, {
+                term: opts.term,
+                first: opts.limit ?? 50,
+                filter: mergeIssueScopeFilter(ctx, opts.filter) ?? null,
+                includeComments: opts.includeComments ?? null,
+                includeArchived: opts.includeArchived ?? null,
+                teamId: opts.teamId ?? null,
+                orderBy: opts.orderBy ?? null,
+                after: opts.after ?? null,
+                before: opts.before ?? null,
+            });
+            return data.searchIssues;
+        },
+    });
+    rl.registerAction("issue.addLabel", {
+        description: "Add a single label to an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            labelId: t.String(),
+        }),
+        async execute(input, ctx) {
+            const { issueId, labelId } = input;
+            await assertIssueInScope(ctx, issueId);
+            const data = await gql(key(ctx), `mutation($id: String!, $labelId: String!) { issueAddLabel(id: $id, labelId: $labelId) { success } }`, { id: issueId, labelId });
+            return data.issueAddLabel;
+        },
+    });
+    rl.registerAction("issue.removeLabel", {
+        description: "Remove a single label from an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            labelId: t.String(),
+        }),
+        async execute(input, ctx) {
+            const { issueId, labelId } = input;
+            await assertIssueInScope(ctx, issueId);
+            forbidScopeLabelRemoval(ctx, labelId);
+            const data = await gql(key(ctx), `mutation($id: String!, $labelId: String!) { issueRemoveLabel(id: $id, labelId: $labelId) { success } }`, { id: issueId, labelId });
+            return data.issueRemoveLabel;
+        },
+    });
+    rl.registerAction("issue.subscribe", {
+        description: "Subscribe a user to issue notifications (defaults to current user).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            userId: t.Optional(t.String()),
+            userEmail: t.Optional(t.String()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, userId, userEmail } = input;
+            await assertIssueInScope(ctx, String(issueId));
+            const data = await gql(key(ctx), `mutation($id: String!, $userId: String, $userEmail: String) {
+          issueSubscribe(id: $id, userId: $userId, userEmail: $userEmail) { success }
+        }`, { id: issueId, userId: userId ?? null, userEmail: userEmail ?? null });
+            return data.issueSubscribe;
+        },
+    });
+    rl.registerAction("issue.unsubscribe", {
+        description: "Unsubscribe a user from issue notifications (defaults to current user).",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            userId: t.Optional(t.String()),
+            userEmail: t.Optional(t.String()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, userId, userEmail } = input;
+            await assertIssueInScope(ctx, String(issueId));
+            const data = await gql(key(ctx), `mutation($id: String!, $userId: String, $userEmail: String) {
+          issueUnsubscribe(id: $id, userId: $userId, userEmail: $userEmail) { success }
+        }`, { id: issueId, userId: userId ?? null, userEmail: userEmail ?? null });
+            return data.issueUnsubscribe;
+        },
+    });
+    rl.registerAction("issue.addLink", {
+        description: "Create a relation between two issues.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The identifier of the issue that is related to another issue. UUID or issue identifier (e.g., 'LIN-123')" }),
+            relatedIssueId: t.String({ description: "The identifier of the related issue. UUID or issue identifier (e.g., 'LIN-123')" }),
+            type: t.String({ description: "IssueRelationType: blocks | duplicate | related | similar" }),
+        }),
+        async execute(input, ctx) {
+            const fields = input;
+            await assertIssueInScope(ctx, String(fields.issueId));
+            await assertIssueInScope(ctx, String(fields.relatedIssueId));
+            const data = await gql(key(ctx), `mutation($input: IssueRelationCreateInput!) { issueRelationCreate(input: $input) { success issueRelation { id type } } }`, { input: fields });
+            return data.issueRelationCreate;
+        },
+    });
+    rl.registerAction("issue.listComments", {
+        description: "List comments on an issue.",
+        inputSchema: t.Object({
+            issueId: t.String(),
+            limit: t.Optional(t.Number()),
+        }),
+        async execute(input, ctx) {
+            const { issueId, limit } = input;
+            await assertIssueInScope(ctx, issueId);
+            const data = await gql(key(ctx), `query($id: String!, $first: Int) {
+          issue(id: $id) { comments(first: $first) { nodes { ${COMMENT_FIELDS} } } }
+        }`, { id: issueId, first: limit ?? 50 });
+            return data.issue?.comments?.nodes;
+        },
+    });
+}

package/dist/plugins/linear/src/labels.js

@@ -0,0 +1,74 @@
+import * as t from "typebox";
+import { LABEL_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+export function registerLabelActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("label.list", "List labels (workspace + team-scoped).", "issueLabels", "IssueLabelFilter", LABEL_FIELDS);
+    getAction("label.get", "Get a label by ID.", "issueLabel", LABEL_FIELDS);
+    rl.registerAction("label.create", {
+        description: "Create a label. Omit teamId for a workspace-level label.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the label" }),
+            teamId: t.Optional(t.String({ description: "The team associated with the label. If omitted, the label is workspace-scoped" })),
+            color: t.Optional(t.String({ description: "The color of the label (hex)" })),
+            description: t.Optional(t.String({ description: "The description of the label" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent label (group label)" })),
+            isGroup: t.Optional(t.Boolean({ description: "Whether the label is a group" })),
+            retiredAt: t.Optional(t.String({ description: "The time at which the label was retired (DateTime). Set to null to restore a retired label" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            replaceTeamLabels: t.Optional(t.Boolean({ description: "Replace all team-specific labels with the same name with this newly created workspace label (default false)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "label.create");
+            const { replaceTeamLabels, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($input: IssueLabelCreateInput!, $replaceTeamLabels: Boolean) { issueLabelCreate(input: $input, replaceTeamLabels: $replaceTeamLabels) { success issueLabel { ${LABEL_FIELDS} } } }`, { input: fields, replaceTeamLabels: replaceTeamLabels ?? null });
+            return data.issueLabelCreate?.issueLabel;
+        },
+    });
+    rl.registerAction("label.update", {
+        description: "Update a label.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the label to update" }),
+            name: t.Optional(t.String({ description: "The name of the label" })),
+            color: t.Optional(t.String({ description: "The color of the label (hex)" })),
+            description: t.Optional(t.String({ description: "The description of the label" })),
+            parentId: t.Optional(t.String({ description: "The identifier of the parent label" })),
+            isGroup: t.Optional(t.Boolean({ description: "Whether the label is a group" })),
+            retiredAt: t.Optional(t.String({ description: "The time at which the label was retired (DateTime). Set to null to restore a retired label" })),
+            replaceTeamLabels: t.Optional(t.Boolean({ description: "Replace all team-specific labels with the same name with this updated workspace label (default false)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "label.update");
+            const { id, replaceTeamLabels, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: IssueLabelUpdateInput!, $replaceTeamLabels: Boolean) { issueLabelUpdate(id: $id, input: $input, replaceTeamLabels: $replaceTeamLabels) { success issueLabel { ${LABEL_FIELDS} } } }`, { id, input: fields, replaceTeamLabels: replaceTeamLabels ?? null });
+            return data.issueLabelUpdate?.issueLabel;
+        },
+    });
+    rl.registerAction("label.delete", {
+        description: "Delete a label.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to delete" }) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "label.delete");
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelDelete(id: $id) { success } }`, { id: input.id });
+            return data.issueLabelDelete;
+        },
+    });
+    rl.registerAction("label.retire", {
+        description: "Retire a label. Retired labels remain visible but cannot be applied to new issues.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to retire" }) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "label.retire");
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelRetire(id: $id) { success issueLabel { ${LABEL_FIELDS} } } }`, { id: input.id });
+            return data.issueLabelRetire?.issueLabel;
+        },
+    });
+    rl.registerAction("label.restore", {
+        description: "Restore a previously retired label.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the label to restore" }) }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "label.restore");
+            const data = await gql(key(ctx), `mutation($id: String!) { issueLabelRestore(id: $id) { success issueLabel { ${LABEL_FIELDS} } } }`, { id: input.id });
+            return data.issueLabelRestore?.issueLabel;
+        },
+    });
+}

package/dist/plugins/linear/src/organization.js

@@ -0,0 +1,13 @@
+import * as t from "typebox";
+import { ORG_FIELDS, gql, key, requireUnscoped } from "./shared.js";
+export function registerOrganizationActions(rl) {
+    rl.registerAction("org.get", {
+        description: "Get the authenticated workspace.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            requireUnscoped(ctx, "org.get");
+            const data = await gql(key(ctx), `query { organization { ${ORG_FIELDS} } }`);
+            return data.organization;
+        },
+    });
+}