runline 0.8.0 → 0.8.1

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

@@ -0,0 +1,131 @@
+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 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);
+}
+export function registerListAction(rl, name, description, rootField, filterTypeName, selection) {
+    rl.registerAction(name, {
+        description,
+        inputSchema: t.Object(LIST_INPUT_SCHEMA),
+        async execute(input, ctx) {
+            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) {
+            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,39 @@
+import * as t from "typebox";
+import { STATE_FIELDS, bindGetAction, bindListAction, gql, key } 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) {
+            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) {
+            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,74 @@
+import * as t from "typebox";
+import { TEAM_FIELDS, USER_FIELDS, bindGetAction, bindListAction, gql, key, } 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) {
+            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) {
+            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) {
+            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,36 @@
+import * as t from "typebox";
+import { USER_FIELDS, bindGetAction, bindListAction, gql, key } 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) {
+            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;
+        },
+    });
+}

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

@@ -0,0 +1,96 @@
+import * as t from "typebox";
+import { CUSTOM_VIEW_FIELDS, FEED_ITEM_FIELDS, INITIATIVE_FIELDS, ISSUE_LITE, LIST_INPUT_SCHEMA, PROJECT_FIELDS, bindGetAction, bindListAction, buildConnArgs, gql, key, } from "./shared.js";
+export function registerViewActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    function customViewConnectionAction(name, description, connectionField, filterTypeName, selection, includeSubTeamsDescription) {
+        rl.registerAction(name, {
+            description,
+            inputSchema: t.Object({
+                viewId: t.String({ description: "The custom view ID or slug" }),
+                ...LIST_INPUT_SCHEMA,
+                ...(includeSubTeamsDescription
+                    ? { includeSubTeams: t.Optional(t.Boolean({ description: includeSubTeamsDescription })) }
+                    : {}),
+            }),
+            async execute(input, ctx) {
+                const opts = (input ?? {});
+                const { argsDecl, argsCall, vars } = buildConnArgs(opts, filterTypeName);
+                const declParts = ["$id: String!", argsDecl.slice(1, -1)];
+                const callParts = [argsCall.slice(1, -1)];
+                const includeSubTeamsSet = includeSubTeamsDescription !== undefined && opts.includeSubTeams !== undefined;
+                if (includeSubTeamsSet) {
+                    declParts.push("$includeSubTeams: Boolean");
+                    callParts.push("includeSubTeams: $includeSubTeams");
+                    vars.includeSubTeams = opts.includeSubTeams;
+                }
+                const data = await gql(key(ctx), `query(${declParts.join(", ")}) {
+            customView(id: $id) { ${connectionField}(${callParts.join(", ")}) { nodes { ${selection} } pageInfo { hasNextPage endCursor } } }
+          }`, { id: opts.viewId, ...vars });
+                const conn = (data.customView?.[connectionField] ?? {});
+                return { nodes: conn.nodes, pageInfo: conn.pageInfo };
+            },
+        });
+    }
+    listAction("view.list", "List custom views accessible to the user, including personal and shared workspace views. Linear excludes views scoped to a specific project or initiative from this root query.", "customViews", "CustomViewFilter", CUSTOM_VIEW_FIELDS);
+    getAction("view.get", "Get a custom view by ID or slug.", "customView", CUSTOM_VIEW_FIELDS);
+    rl.registerAction("view.create", {
+        description: "Create a custom view. Set filterData for issue views; projectFilterData, initiativeFilterData, or feedItemFilterData for other view types.",
+        inputSchema: t.Object({
+            name: t.String({ description: "The name of the custom view" }),
+            description: t.Optional(t.String({ description: "The description of the custom view" })),
+            icon: t.Optional(t.String({ description: "The icon of the custom view" })),
+            color: t.Optional(t.String({ description: "The color of the custom view icon (hex)" })),
+            shared: t.Optional(t.Boolean({ description: "Whether the custom view is shared with everyone in the workspace" })),
+            filterData: t.Optional(t.Object({}, { description: "IssueFilter for issue views" })),
+            projectFilterData: t.Optional(t.Object({}, { description: "ProjectFilter for project views" })),
+            initiativeFilterData: t.Optional(t.Object({}, { description: "InitiativeFilter for initiative views" })),
+            feedItemFilterData: t.Optional(t.Object({}, { description: "FeedItemFilter for update/feed item views" })),
+            teamId: t.Optional(t.String({ description: "The team associated with the custom view" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the custom view" })),
+            initiativeId: t.Optional(t.String({ description: "The initiative associated with the custom view" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the custom view" })),
+            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 data = await gql(key(ctx), `mutation($input: CustomViewCreateInput!) { customViewCreate(input: $input) { success customView { ${CUSTOM_VIEW_FIELDS} } } }`, { input: input });
+            return data.customViewCreate?.customView;
+        },
+    });
+    rl.registerAction("view.update", {
+        description: "Update a custom view. All fields optional; only provided fields are updated.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the custom view to update" }),
+            name: t.Optional(t.String({ description: "The name of the custom view" })),
+            description: t.Optional(t.String({ description: "The description of the custom view" })),
+            icon: t.Optional(t.String({ description: "The icon of the custom view" })),
+            color: t.Optional(t.String({ description: "The color of the custom view icon (hex)" })),
+            shared: t.Optional(t.Boolean({ description: "Whether the custom view is shared with everyone in the workspace" })),
+            filterData: t.Optional(t.Object({}, { description: "IssueFilter for issue views" })),
+            projectFilterData: t.Optional(t.Object({}, { description: "ProjectFilter for project views" })),
+            initiativeFilterData: t.Optional(t.Object({}, { description: "InitiativeFilter for initiative views" })),
+            feedItemFilterData: t.Optional(t.Object({}, { description: "FeedItemFilter for update/feed item views" })),
+            teamId: t.Optional(t.String({ description: "The team associated with the custom view" })),
+            projectId: t.Optional(t.String({ description: "The project associated with the custom view" })),
+            initiativeId: t.Optional(t.String({ description: "The initiative associated with the custom view" })),
+            ownerId: t.Optional(t.String({ description: "The owner of the custom view" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: CustomViewUpdateInput!) { customViewUpdate(id: $id, input: $input) { success customView { ${CUSTOM_VIEW_FIELDS} } } }`, { id, input: fields });
+            return data.customViewUpdate?.customView;
+        },
+    });
+    rl.registerAction("view.delete", {
+        description: "Delete a custom view.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the custom view to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { customViewDelete(id: $id) { success } }`, { id: input.id });
+            return data.customViewDelete;
+        },
+    });
+    customViewConnectionAction("view.issues", "List issues matching a custom view's issue filter. Returns an empty connection when the view's modelName is not Issue.", "issues", "IssueFilter", ISSUE_LITE, "Include issues from sub-teams when the custom view is associated with a team");
+    customViewConnectionAction("view.projects", "List projects matching a custom view's project filter. Returns an empty connection when the view's modelName is not Project.", "projects", "ProjectFilter", PROJECT_FIELDS, "Include projects from sub-teams when the custom view is associated with a team");
+    customViewConnectionAction("view.initiatives", "List initiatives matching a custom view's initiative filter. Returns an empty connection when the view's modelName is not Initiative.", "initiatives", "InitiativeFilter", INITIATIVE_FIELDS);
+    customViewConnectionAction("view.updates", "List feed items matching a custom view's feed item filter. Returns an empty connection when the view's modelName is not FeedItem.", "updates", "FeedItemFilter", FEED_ITEM_FIELDS, "Include updates from sub-teams when the custom view is associated with a team");
+}

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

@@ -0,0 +1,57 @@
+import * as t from "typebox";
+import { WEBHOOK_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+export function registerWebhookActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("webhook.list", "List webhooks for the current workspace.", "webhooks", null, WEBHOOK_FIELDS);
+    getAction("webhook.get", "Get a webhook by ID.", "webhook", WEBHOOK_FIELDS);
+    rl.registerAction("webhook.create", {
+        description: "Create a webhook. resourceTypes example: ['Issue','Comment','Project'].",
+        inputSchema: t.Object({
+            url: t.String({ description: "The URL that will be called on data changes" }),
+            resourceTypes: t.Array(t.String(), { description: "List of resources the webhook should subscribe to (e.g. ['Issue','Comment'])" }),
+            label: t.Optional(t.String({ description: "Label for the webhook" })),
+            teamId: t.Optional(t.String({ description: "The identifier or key of the team associated with the webhook. Omit and set allPublicTeams=true for workspace-wide" })),
+            allPublicTeams: t.Optional(t.Boolean({ description: "Whether this webhook is enabled for all public teams" })),
+            enabled: t.Optional(t.Boolean({ description: "Whether this webhook is enabled (default true)" })),
+            secret: t.Optional(t.String({ description: "A secret token used to sign the webhook payload" })),
+            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 data = await gql(key(ctx), `mutation($input: WebhookCreateInput!) { webhookCreate(input: $input) { success webhook { ${WEBHOOK_FIELDS} } } }`, { input: input });
+            return data.webhookCreate?.webhook;
+        },
+    });
+    rl.registerAction("webhook.update", {
+        description: "Update a webhook. teamId and allPublicTeams cannot be changed after creation.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the webhook to update" }),
+            url: t.Optional(t.String({ description: "The URL that will be called on data changes" })),
+            resourceTypes: t.Optional(t.Array(t.String(), { description: "List of resources the webhook should subscribe to" })),
+            label: t.Optional(t.String({ description: "Label for the webhook" })),
+            enabled: t.Optional(t.Boolean({ description: "Whether this webhook is enabled" })),
+            secret: t.Optional(t.String({ description: "A secret token used to sign the webhook payload" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: WebhookUpdateInput!) { webhookUpdate(id: $id, input: $input) { success webhook { ${WEBHOOK_FIELDS} } } }`, { id, input: fields });
+            return data.webhookUpdate?.webhook;
+        },
+    });
+    rl.registerAction("webhook.delete", {
+        description: "Delete a webhook.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the webhook to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { webhookDelete(id: $id) { success } }`, { id: input.id });
+            return data.webhookDelete;
+        },
+    });
+    rl.registerAction("webhook.rotateSecret", {
+        description: "Rotate a webhook's signing secret. Returns the new secret.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the webhook to rotate the secret for" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { webhookRotateSecret(id: $id) { success secret } }`, { id: input.id });
+            return data.webhookRotateSecret;
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -68,6 +68,7 @@
     "jiti": "^2.7.0",
     "proper-lockfile": "^4.1.2",
     "quickjs-emscripten": "^0.32.0",
-    "rrule": "^2.8.1"
+    "rrule": "^2.8.1",
+    "typebox": "^1.1.35"
   }
 }