runline 0.8.0 → 0.9.0

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

@@ -0,0 +1,200 @@
+import * as t from "typebox";
+import { MILESTONE_FIELDS, PROJECT_FIELDS, PROJECT_UPDATE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped, } from "./shared.js";
+export function registerProjectActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("project.list", "List projects.", "projects", "ProjectFilter", PROJECT_FIELDS);
+    getAction("project.get", "Get a project by ID or slug.", "project", PROJECT_FIELDS);
+    rl.registerAction("project.create", {
+        description: "Create a project. teamIds is required.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the project" }),
+            teamIds: t.Array(t.Unknown(), { description: "The identifiers of the teams this project is associated with" }),
+            description: t.Optional(t.String({ description: "The description for the project" })),
+            content: t.Optional(t.String({ description: "The project content as markdown" })),
+            icon: t.Optional(t.String({ description: "The icon of the project" })),
+            color: t.Optional(t.String({ description: "The color of the project (hex)" })),
+            priority: t.Optional(t.Number({ description: "The priority of the project. 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            leadId: t.Optional(t.String({ description: "The identifier of the project lead" })),
+            memberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the members of this project" })),
+            startDate: t.Optional(t.String({ description: "The planned start date of the project (TimelessDate, YYYY-MM-DD)" })),
+            startDateResolution: t.Optional(t.String({ description: "The resolution of the project's start date (DateResolutionType)" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date of the project (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the project's estimated completion date (DateResolutionType)" })),
+            statusId: t.Optional(t.String({ description: "The ID of the project status" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the project labels associated with this project" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project in shared views (Float)" })),
+            templateId: t.Optional(t.String({ description: "The ID of a project template to apply when creating the project" })),
+            useDefaultTemplate: t.Optional(t.Boolean({ description: "Apply the default project template of the first team provided. Ignored if templateId is set" })),
+            convertedFromIssueId: t.Optional(t.String({ description: "The ID of the issue that was converted into this project" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            slackChannelName: t.Optional(t.String({ description: "The full name for the Slack channel to create (including prefix). Creates and connects a Slack channel if provided" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const { slackChannelName, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($input: ProjectCreateInput!, $slackChannelName: String) { projectCreate(input: $input, slackChannelName: $slackChannelName) { success project { ${PROJECT_FIELDS} } } }`, { input: fields, slackChannelName: slackChannelName ?? null });
+            return data.projectCreate?.project;
+        },
+    });
+    rl.registerAction("project.update", {
+        description: "Update a project.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project to update (UUID or slug)" }),
+            name: t.Optional(t.String({ description: "The name of the project" })),
+            description: t.Optional(t.String({ description: "The description for the project" })),
+            content: t.Optional(t.String({ description: "The project content as markdown" })),
+            icon: t.Optional(t.String({ description: "The icon of the project" })),
+            color: t.Optional(t.String({ description: "The color of the project (hex)" })),
+            priority: t.Optional(t.Number({ description: "The priority of the project. 0=No, 1=Urgent, 2=High, 3=Medium, 4=Low" })),
+            leadId: t.Optional(t.String({ description: "The identifier of the project lead" })),
+            memberIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the members of this project" })),
+            startDate: t.Optional(t.String({ description: "The planned start date (TimelessDate, YYYY-MM-DD)" })),
+            startDateResolution: t.Optional(t.String({ description: "The resolution of the project's start date (DateResolutionType)" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date (TimelessDate, YYYY-MM-DD)" })),
+            targetDateResolution: t.Optional(t.String({ description: "The resolution of the project's estimated completion date (DateResolutionType)" })),
+            statusId: t.Optional(t.String({ description: "The ID of the project status" })),
+            labelIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the project labels associated with this project" })),
+            teamIds: t.Optional(t.Array(t.Unknown(), { description: "The identifiers of the teams this project is associated with" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project in shared views (Float)" })),
+            completedAt: t.Optional(t.String({ description: "The time at which the project was completed (DateTime)" })),
+            canceledAt: t.Optional(t.String({ description: "The time at which the project was canceled (DateTime)" })),
+            trashed: t.Optional(t.Boolean({ description: "Whether the project has been trashed. Set to true to trash, or null to restore" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectUpdateInput!) { projectUpdate(id: $id, input: $input) { success project { ${PROJECT_FIELDS} } } }`, { id, input: fields });
+            return data.projectUpdate?.project;
+        },
+    });
+    rl.registerAction("project.delete", {
+        description: "Trash (soft-delete) a project. Restorable via project.unarchive.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project to delete" }), }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { projectDelete(id: $id) { success } }`, { id: input.id });
+            return data.projectDelete;
+        },
+    });
+    rl.registerAction("project.unarchive", {
+        description: "Restore a previously trashed or archived project.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project to restore (UUID or slug)" }), }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { projectUnarchive(id: $id) { success } }`, { id: input.id });
+            return data.projectUnarchive;
+        },
+    });
+    rl.registerAction("project.search", {
+        description: "Search projects by text. 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)" })),
+            includeComments: t.Optional(t.Boolean({ description: "Should associated comments be searched (default false)" })),
+            teamId: t.Optional(t.String({ description: "UUID of a team to boost in search results" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const opts = input;
+            const data = await gql(key(ctx), `query($term: String!, $first: Int, $includeComments: Boolean, $teamId: String) {
+          searchProjects(term: $term, first: $first, includeComments: $includeComments, teamId: $teamId) {
+            nodes { ${PROJECT_FIELDS} }
+            totalCount
+          }
+        }`, {
+                term: opts.term,
+                first: opts.limit ?? 50,
+                includeComments: opts.includeComments ?? null,
+                teamId: opts.teamId ?? null,
+            });
+            return data.searchProjects;
+        },
+    });
+    // Project milestones
+    listAction("milestone.list", "List project milestones.", "projectMilestones", "ProjectMilestoneFilter", MILESTONE_FIELDS);
+    getAction("milestone.get", "Get a project milestone by ID.", "projectMilestone", MILESTONE_FIELDS);
+    rl.registerAction("milestone.create", {
+        description: "Create a project milestone.",
+        inputSchema: t.Object({
+            projectId: t.String({ description: "Related project for the project milestone" }),
+            name: t.String({ description: "The name of the project milestone" }),
+            description: t.Optional(t.String({ description: "The description of the project milestone in markdown format" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date of the project milestone (TimelessDate, YYYY-MM-DD)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project milestone within a project (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, "projects.*");
+            const data = await gql(key(ctx), `mutation($input: ProjectMilestoneCreateInput!) { projectMilestoneCreate(input: $input) { success projectMilestone { ${MILESTONE_FIELDS} } } }`, { input: input });
+            return data.projectMilestoneCreate?.projectMilestone;
+        },
+    });
+    rl.registerAction("milestone.update", {
+        description: "Update a project milestone.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project milestone to update" }),
+            name: t.Optional(t.String({ description: "The name of the project milestone" })),
+            description: t.Optional(t.String({ description: "The description of the project milestone in markdown format" })),
+            targetDate: t.Optional(t.String({ description: "The planned target date (TimelessDate, YYYY-MM-DD)" })),
+            projectId: t.Optional(t.String({ description: "Related project for the project milestone (move to another project)" })),
+            sortOrder: t.Optional(t.Number({ description: "The sort order for the project milestone within a project (Float)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectMilestoneUpdateInput!) { projectMilestoneUpdate(id: $id, input: $input) { success projectMilestone { ${MILESTONE_FIELDS} } } }`, { id, input: fields });
+            return data.projectMilestoneUpdate?.projectMilestone;
+        },
+    });
+    rl.registerAction("milestone.delete", {
+        description: "Delete a project milestone.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project milestone to delete" }), }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { projectMilestoneDelete(id: $id) { success } }`, { id: input.id });
+            return data.projectMilestoneDelete;
+        },
+    });
+    // Project updates
+    listAction("projectUpdate.list", "List project updates.", "projectUpdates", "ProjectUpdateFilter", PROJECT_UPDATE_FIELDS);
+    rl.registerAction("projectUpdate.create", {
+        description: "Post a status update on a project.",
+        inputSchema: t.Object({
+            projectId: t.String({ description: "The project to associate the project update with" }),
+            body: t.Optional(t.String({ description: "The content of the project update in markdown format" })),
+            health: t.Optional(t.String({ description: "The health of the project at the time of the update (ProjectUpdateHealthType: onTrack | atRisk | offTrack)" })),
+            isDiffHidden: t.Optional(t.Boolean({ description: "Whether the diff between the current update and the previous one should be hidden" })),
+            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, "projects.*");
+            const data = await gql(key(ctx), `mutation($input: ProjectUpdateCreateInput!) { projectUpdateCreate(input: $input) { success projectUpdate { ${PROJECT_UPDATE_FIELDS} } } }`, { input: input });
+            return data.projectUpdateCreate?.projectUpdate;
+        },
+    });
+    rl.registerAction("projectUpdate.update", {
+        description: "Update a project status update.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the project update to update" }),
+            body: t.Optional(t.String({ description: "The content of the project update in markdown format" })),
+            health: t.Optional(t.String({ description: "The health of the project at the time of the update (ProjectUpdateHealthType: onTrack | atRisk | offTrack)" })),
+            isDiffHidden: t.Optional(t.Boolean({ description: "Whether the diff between the current update and the previous one should be hidden" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: ProjectUpdateUpdateInput!) { projectUpdateUpdate(id: $id, input: $input) { success projectUpdate { ${PROJECT_UPDATE_FIELDS} } } }`, { id, input: fields });
+            return data.projectUpdateUpdate?.projectUpdate;
+        },
+    });
+    rl.registerAction("projectUpdate.archive", {
+        description: "Archive a project status update.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the project update to archive" }), }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "projects.*");
+            const data = await gql(key(ctx), `mutation($id: String!) { projectUpdateArchive(id: $id) { success } }`, { id: input.id });
+            return data.projectUpdateArchive;
+        },
+    });
+}

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

@@ -0,0 +1,234 @@
+import * as t from "typebox";
+const GQL_URL = "https://api.linear.app/graphql";
+export async function gql(apiKey, query, variables) {
+    const body = { query };
+    if (variables)
+        body.variables = variables;
+    const res = await fetch(GQL_URL, {
+        method: "POST",
+        headers: { Authorization: apiKey, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Linear API error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.errors)
+        throw new Error(`Linear GraphQL error: ${JSON.stringify(data.errors)}`);
+    return data.data;
+}
+export function key(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export function scopeLabelIds(ctx) {
+    const raw = ctx.connection.config.scopeLabelIds;
+    if (Array.isArray(raw))
+        return raw.map(String).map((s) => s.trim()).filter(Boolean);
+    if (typeof raw !== "string")
+        return [];
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+export function isScoped(ctx) {
+    return scopeLabelIds(ctx).length > 0;
+}
+export function mergeIssueScopeFilter(ctx, filter) {
+    const ids = scopeLabelIds(ctx);
+    if (ids.length === 0)
+        return filter;
+    const scopeFilter = { labels: { id: { in: ids } } };
+    if (!filter || Object.keys(filter).length === 0)
+        return scopeFilter;
+    return { and: [filter, scopeFilter] };
+}
+export function issueHasScope(ctx, issue) {
+    const ids = new Set(scopeLabelIds(ctx));
+    if (ids.size === 0)
+        return true;
+    const labels = issue?.labels?.nodes;
+    return Array.isArray(labels) && labels.some((label) => ids.has(String(label.id)));
+}
+export async function getIssueForScope(ctx, issueId) {
+    const data = await gql(key(ctx), `query($id: String!) { issue(id: $id) { id identifier labels { nodes { id name } } } }`, { id: issueId });
+    return data.issue ?? null;
+}
+export async function assertIssueInScope(ctx, issueId) {
+    if (!isScoped(ctx))
+        return null;
+    const issue = await getIssueForScope(ctx, issueId);
+    if (!issue || !issueHasScope(ctx, issue))
+        throw new Error("Linear issue is not available to this scoped connection");
+    return issue;
+}
+export async function assertCommentInScope(ctx, commentId) {
+    if (!isScoped(ctx))
+        return;
+    const data = await gql(key(ctx), `query($id: String!) { comment(id: $id) { id issue { id identifier labels { nodes { id name } } } } }`, { id: commentId });
+    const issue = data.comment?.issue;
+    if (!issue || !issueHasScope(ctx, issue))
+        throw new Error("Linear comment is not available to this scoped connection");
+}
+export async function assertAttachmentInScope(ctx, attachmentId) {
+    if (!isScoped(ctx))
+        return;
+    const data = await gql(key(ctx), `query($id: String!) { attachment(id: $id) { id issue { id identifier labels { nodes { id name } } } } }`, { id: attachmentId });
+    const issue = data.attachment?.issue;
+    if (!issue || !issueHasScope(ctx, issue))
+        throw new Error("Linear attachment is not available to this scoped connection");
+}
+export function forbidScopeLabelRemoval(ctx, labelIds) {
+    const scoped = new Set(scopeLabelIds(ctx));
+    if (scoped.size === 0)
+        return;
+    const ids = Array.isArray(labelIds) ? labelIds.map(String) : [String(labelIds)];
+    if (ids.some((id) => scoped.has(id))) {
+        throw new Error("Cannot remove a required Linear scope label");
+    }
+}
+export function ensureScopeLabelsOnCreateOrReplace(ctx, labelIds) {
+    const scoped = scopeLabelIds(ctx);
+    if (scoped.length === 0)
+        return labelIds;
+    const ids = new Set(Array.isArray(labelIds) ? labelIds.map(String) : []);
+    for (const id of scoped)
+        ids.add(id);
+    return [...ids];
+}
+export function requireUnscoped(ctx, action) {
+    if (isScoped(ctx)) {
+        throw new Error(`${action} is not available to scoped Linear connections`);
+    }
+}
+export const ISSUE_FIELDS = `id identifier title description url priority estimate dueDate
+  state { id name type } assignee { id name email } creator { id name }
+  team { id key name } project { id name } cycle { id number name }
+  projectMilestone { id name } parent { id identifier }
+  labels { nodes { id name color } }
+  createdAt updatedAt completedAt canceledAt archivedAt`;
+export const ISSUE_LITE = `id identifier title url priority state { id name type } assignee { id name } team { key } updatedAt`;
+export const COMMENT_FIELDS = `id body url issue { id identifier } user { id name } parent { id } createdAt updatedAt editedAt resolvedAt`;
+export const STATE_FIELDS = `id name type color position description team { id key }`;
+export const LABEL_FIELDS = `id name color description isGroup parent { id name } team { id key } createdAt`;
+export const PROJECT_FIELDS = `id name description url icon color priority progress health
+  state status { id name type } lead { id name } startDate targetDate
+  teams { nodes { id key } } createdAt updatedAt completedAt canceledAt`;
+export const MILESTONE_FIELDS = `id name description targetDate sortOrder project { id name } createdAt updatedAt`;
+export const PROJECT_UPDATE_FIELDS = `id body health url user { id name } project { id name } createdAt`;
+export const FEED_ITEM_FIELDS = `id createdAt updatedAt archivedAt team { id key name } user { id name }
+  projectUpdate { ${PROJECT_UPDATE_FIELDS} }
+  initiativeUpdate { id body health url user { id name } initiative { id name } createdAt }
+  post { id title body slugId type creator { id name } createdAt updatedAt }`;
+export const CUSTOM_VIEW_FIELDS = `id name description icon color shared slugId modelName
+  filterData projectFilterData initiativeFilterData feedItemFilterData
+  team { id key name } owner { id name } creator { id name }
+  createdAt updatedAt archivedAt`;
+export const CYCLE_FIELDS = `id number name description startsAt endsAt completedAt progress team { id key } createdAt`;
+export const INITIATIVE_FIELDS = `id name description url icon color status targetDate owner { id name }
+  projects { nodes { id name } } createdAt updatedAt completedAt`;
+export const TEAM_FIELDS = `id key name description icon color private timezone
+  cyclesEnabled cycleDuration issueEstimationType triageEnabled
+  parent { id key } createdAt`;
+export const USER_FIELDS = `id name displayName email avatarUrl active admin guest
+  isMe statusEmoji statusLabel createdAt`;
+export const ATTACHMENT_FIELDS = `id title subtitle url sourceType groupBySource metadata
+  issue { id identifier } creator { id name } createdAt updatedAt`;
+export const ORG_FIELDS = `id name urlKey logoUrl userCount createdIssueCount
+  periodUploadVolume samlEnabled scimEnabled createdAt`;
+export const WEBHOOK_FIELDS = `id label url enabled resourceTypes secret
+  team { id key } allPublicTeams createdAt`;
+export function buildConnArgs(opts, filterTypeName) {
+    const declParts = [];
+    const callParts = [`first: $first`];
+    const vars = { first: opts.limit ?? 50 };
+    declParts.push(`$first: Int`);
+    if (filterTypeName && opts.filter !== undefined) {
+        declParts.push(`$filter: ${filterTypeName}`);
+        callParts.push(`filter: $filter`);
+        vars.filter = opts.filter;
+    }
+    if (opts.includeArchived !== undefined) {
+        declParts.push(`$includeArchived: Boolean`);
+        callParts.push(`includeArchived: $includeArchived`);
+        vars.includeArchived = opts.includeArchived;
+    }
+    if (opts.orderBy !== undefined) {
+        declParts.push(`$orderBy: PaginationOrderBy`);
+        callParts.push(`orderBy: $orderBy`);
+        vars.orderBy = opts.orderBy;
+    }
+    if (opts.after !== undefined) {
+        declParts.push(`$after: String`);
+        callParts.push(`after: $after`);
+        vars.after = opts.after;
+    }
+    if (opts.before !== undefined) {
+        declParts.push(`$before: String`);
+        callParts.push(`before: $before`);
+        vars.before = opts.before;
+    }
+    return {
+        argsDecl: `(${declParts.join(", ")})`,
+        argsCall: `(${callParts.join(", ")})`,
+        vars,
+    };
+}
+export const LIST_INPUT_SCHEMA = {
+    limit: t.Optional(t.Number({ description: "Max results (default 50, max 250)" })),
+    filter: t.Optional(t.Object({}, { description: "Linear filter object (see schema for the resource)" })),
+    includeArchived: t.Optional(t.Boolean({ description: "Include archived items" })),
+    orderBy: t.Optional(t.String({ description: "createdAt | updatedAt" })),
+    after: t.Optional(t.String({ description: "Cursor for forward pagination" })),
+    before: t.Optional(t.String({ description: "Cursor for backward pagination" })),
+};
+export function bindListAction(rl) {
+    return (...args) => registerListAction(rl, ...args);
+}
+export function bindGetAction(rl) {
+    return (...args) => registerGetAction(rl, ...args);
+}
+const SCOPED_BLOCKED_ROOT_FIELDS = new Set([
+    "attachments",
+    "comments",
+    "customView",
+    "customViews",
+    "cycle",
+    "cycles",
+    "initiative",
+    "initiatives",
+    "project",
+    "projects",
+    "projectMilestone",
+    "projectMilestones",
+    "projectUpdates",
+    "user",
+    "users",
+    "webhook",
+    "webhooks",
+]);
+function requireRootFieldAvailable(ctx, action, rootField) {
+    if (SCOPED_BLOCKED_ROOT_FIELDS.has(rootField))
+        requireUnscoped(ctx, action);
+}
+export function registerListAction(rl, name, description, rootField, filterTypeName, selection) {
+    rl.registerAction(name, {
+        description,
+        inputSchema: t.Object(LIST_INPUT_SCHEMA),
+        async execute(input, ctx) {
+            requireRootFieldAvailable(ctx, name, rootField);
+            const opts = (input ?? {});
+            const { argsDecl, argsCall, vars } = buildConnArgs(opts, filterTypeName);
+            const data = await gql(key(ctx), `query${argsDecl} { ${rootField}${argsCall} { nodes { ${selection} } pageInfo { hasNextPage endCursor } } }`, vars);
+            const conn = data[rootField];
+            return { nodes: conn.nodes, pageInfo: conn.pageInfo };
+        },
+    });
+}
+export function registerGetAction(rl, name, description, rootField, selection) {
+    rl.registerAction(name, {
+        description,
+        inputSchema: t.Object({ id: t.String({ description: "Identifier or slug" }) }),
+        async execute(input, ctx) {
+            requireRootFieldAvailable(ctx, name, rootField);
+            const data = await gql(key(ctx), `query($id: String!) { ${rootField}(id: $id) { ${selection} } }`, { id: input.id });
+            return data[rootField];
+        },
+    });
+}

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

@@ -0,0 +1,41 @@
+import * as t from "typebox";
+import { STATE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+export function registerStateActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("state.list", "List workflow states. Filter by team for team-scoped states.", "workflowStates", "WorkflowStateFilter", STATE_FIELDS);
+    getAction("state.get", "Get a workflow state by ID.", "workflowState", STATE_FIELDS);
+    rl.registerAction("state.create", {
+        description: "Create a workflow state in a team.",
+        inputSchema: t.Object({
+            teamId: t.String({ description: "The team associated with the state" }),
+            name: t.String({ description: "The name of the state" }),
+            type: t.String({ description: "The workflow state type which categorizes the state. Valid values: backlog, unstarted, started, completed, canceled" }),
+            color: t.String({ description: "The color of the state (hex, e.g. #6B7280)" }),
+            description: t.Optional(t.String({ description: "The description of the state" })),
+            position: t.Optional(t.Number({ description: "The position of the state (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, "state.create");
+            const data = await gql(key(ctx), `mutation($input: WorkflowStateCreateInput!) { workflowStateCreate(input: $input) { success workflowState { ${STATE_FIELDS} } } }`, { input: input });
+            return data.workflowStateCreate?.workflowState;
+        },
+    });
+    rl.registerAction("state.update", {
+        description: "Update a workflow state. Type cannot be changed after creation.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the state to update" }),
+            name: t.Optional(t.String({ description: "The name of the state" })),
+            color: t.Optional(t.String({ description: "The color of the state (hex)" })),
+            description: t.Optional(t.String({ description: "The description of the state" })),
+            position: t.Optional(t.Number({ description: "The position of the state (Float)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "state.update");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: WorkflowStateUpdateInput!) { workflowStateUpdate(id: $id, input: $input) { success workflowState { ${STATE_FIELDS} } } }`, { id, input: fields });
+            return data.workflowStateUpdate?.workflowState;
+        },
+    });
+}

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

@@ -0,0 +1,77 @@
+import * as t from "typebox";
+import { TEAM_FIELDS, USER_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped, } from "./shared.js";
+export function registerTeamActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("team.list", "List teams whose issues you can access.", "teams", "TeamFilter", TEAM_FIELDS);
+    getAction("team.get", "Get a team by ID or key.", "team", TEAM_FIELDS);
+    rl.registerAction("team.create", {
+        description: "Create a team. Most settings have sensible defaults.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the team" }),
+            key: t.Optional(t.String({ description: "The key of the team. If not given, the key will be generated based on the name" })),
+            description: t.Optional(t.String({ description: "The description of the team" })),
+            icon: t.Optional(t.String({ description: "The icon of the team" })),
+            color: t.Optional(t.String({ description: "The color of the team (hex)" })),
+            private: t.Optional(t.Boolean({ description: "Whether the team is private" })),
+            timezone: t.Optional(t.String({ description: "The timezone of the team" })),
+            cyclesEnabled: t.Optional(t.Boolean({ description: "Whether the team uses cycles" })),
+            cycleDuration: t.Optional(t.Number({ description: "The duration of each cycle in weeks (Int)" })),
+            cycleCooldownTime: t.Optional(t.Number({ description: "The cooldown time after each cycle in weeks (Int)" })),
+            cycleStartDay: t.Optional(t.Number({ description: "The day of the week that a new cycle starts. 0=Sun..6=Sat (Float)" })),
+            upcomingCycleCount: t.Optional(t.Number({ description: "How many upcoming cycles to create (Float)" })),
+            issueEstimationType: t.Optional(t.String({ description: "The issue estimation type: notUsed | exponential | fibonacci | linear | tShirt" })),
+            triageEnabled: t.Optional(t.Boolean({ description: "Whether triage mode is enabled for the team" })),
+            parentId: t.Optional(t.String({ description: "The parent team ID (for sub-teams)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+            copySettingsFromTeamId: t.Optional(t.String({ description: "The team id to copy settings from, if any" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "team.create");
+            const { copySettingsFromTeamId, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($input: TeamCreateInput!, $copySettingsFromTeamId: String) { teamCreate(input: $input, copySettingsFromTeamId: $copySettingsFromTeamId) { success team { ${TEAM_FIELDS} } } }`, { input: fields, copySettingsFromTeamId: copySettingsFromTeamId ?? null });
+            return data.teamCreate?.team;
+        },
+    });
+    rl.registerAction("team.update", {
+        description: "Update a team. Requires team owner or workspace admin permissions.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the team to update" }),
+            name: t.Optional(t.String({ description: "The name of the team" })),
+            key: t.Optional(t.String({ description: "The key of the team" })),
+            description: t.Optional(t.String({ description: "The description of the team" })),
+            icon: t.Optional(t.String({ description: "The icon of the team" })),
+            color: t.Optional(t.String({ description: "The color of the team (hex)" })),
+            private: t.Optional(t.Boolean({ description: "Whether the team is private" })),
+            timezone: t.Optional(t.String({ description: "The timezone of the team" })),
+            cyclesEnabled: t.Optional(t.Boolean({ description: "Whether the team uses cycles" })),
+            cycleDuration: t.Optional(t.Number({ description: "The duration of each cycle in weeks (Int)" })),
+            cycleCooldownTime: t.Optional(t.Number({ description: "The cooldown time after each cycle in weeks (Int)" })),
+            cycleStartDay: t.Optional(t.Number({ description: "The day of the week that a new cycle starts. 0=Sun..6=Sat (Float)" })),
+            upcomingCycleCount: t.Optional(t.Number({ description: "How many upcoming cycles to create (Float)" })),
+            issueEstimationType: t.Optional(t.String({ description: "The issue estimation type: notUsed | exponential | fibonacci | linear | tShirt" })),
+            triageEnabled: t.Optional(t.Boolean({ description: "Whether triage mode is enabled for the team" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "team.update");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: TeamUpdateInput!) { teamUpdate(id: $id, input: $input) { success team { ${TEAM_FIELDS} } } }`, { id, input: fields });
+            return data.teamUpdate?.team;
+        },
+    });
+    rl.registerAction("team.members", {
+        description: "List members of a team.",
+        inputSchema: t.Object({
+            teamId: t.String({ description: "The identifier of the team" }),
+            limit: t.Optional(t.Number({ description: "Max members to return (default 50)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "team.members");
+            const { teamId, limit } = input;
+            const data = await gql(key(ctx), `query($id: String!, $first: Int) {
+          team(id: $id) { members(first: $first) { nodes { ${USER_FIELDS} } } }
+        }`, { id: teamId, first: limit ?? 50 });
+            return data.team?.members?.nodes;
+        },
+    });
+}

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

@@ -0,0 +1,37 @@
+import * as t from "typebox";
+import { USER_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
+export function registerUserActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("user.list", "List users in the workspace.", "users", "UserFilter", USER_FIELDS);
+    getAction("user.get", "Get a user by ID. Use 'me' to reference the authenticated user.", "user", USER_FIELDS);
+    rl.registerAction("user.me", {
+        description: "Get the authenticated user.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            const data = await gql(key(ctx), `query { viewer { ${USER_FIELDS} } }`);
+            return data.viewer;
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user. Use id='me' to update the authenticated user.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the user to update. Use 'me' to reference the currently authenticated user" }),
+            name: t.Optional(t.String({ description: "The name of the user" })),
+            displayName: t.Optional(t.String({ description: "The display name of the user" })),
+            description: t.Optional(t.String({ description: "The user description or short bio" })),
+            avatarUrl: t.Optional(t.String({ description: "The avatar image URL of the user" })),
+            timezone: t.Optional(t.String({ description: "The local timezone of the user" })),
+            title: t.Optional(t.String({ description: "The user's job title" })),
+            statusEmoji: t.Optional(t.String({ description: "The emoji part of the user status" })),
+            statusLabel: t.Optional(t.String({ description: "The label part of the user status" })),
+            statusUntilAt: t.Optional(t.String({ description: "When the user status should be cleared (DateTime)" })),
+        }),
+        async execute(input, ctx) {
+            requireUnscoped(ctx, "user.update");
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: UserUpdateInput!) { userUpdate(id: $id, input: $input) { success user { ${USER_FIELDS} } } }`, { id, input: fields });
+            return data.userUpdate?.user;
+        },
+    });
+}