runline 0.8.1 → 0.9.0

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

@@ -19,6 +19,84 @@ export async function gql(apiKey, query, variables) {
 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 }
@@ -106,11 +184,35 @@ export function bindListAction(rl) {
 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);
@@ -124,6 +226,7 @@ export function registerGetAction(rl, name, description, rootField, selection) {
         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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { STATE_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+import { STATE_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
 export function registerStateActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -17,6 +17,7 @@ export function registerStateActions(rl) {
             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;
         },
@@ -31,6 +32,7 @@ export function registerStateActions(rl) {
             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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { TEAM_FIELDS, USER_FIELDS, bindGetAction, bindListAction, gql, key, } from "./shared.js";
+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);
@@ -27,6 +27,7 @@ export function registerTeamActions(rl) {
             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;
@@ -52,6 +53,7 @@ export function registerTeamActions(rl) {
             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;
@@ -64,6 +66,7 @@ export function registerTeamActions(rl) {
             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} } } }

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { USER_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+import { USER_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
 export function registerUserActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -28,6 +28,7 @@ export function registerUserActions(rl) {
             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;

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

@@ -1,5 +1,6 @@
 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";
+import { CUSTOM_VIEW_FIELDS, FEED_ITEM_FIELDS, INITIATIVE_FIELDS, ISSUE_LITE, LIST_INPUT_SCHEMA, PROJECT_FIELDS, bindGetAction, bindListAction, buildConnArgs, gql, key, mergeIssueScopeFilter, requireUnscoped, } from "./shared.js";
+const ISSUE_FILTER_DESCRIPTION = "IssueFilter payload. Examples: label { labels: { id: { in: ['label-id'] } } }; project { project: { id: { eq: 'project-id' } } }; assignee { assignee: { id: { eq: 'user-id' } } }; state { state: { id: { eq: 'state-id' } } }; priority { priority: { eq: 1 } }; due window { dueDate: { gte: '2026-06-09', lte: '2026-06-16' } }; combine with and/or arrays.";
 export function registerViewActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -15,7 +16,12 @@ export function registerViewActions(rl) {
             }),
             async execute(input, ctx) {
                 const opts = (input ?? {});
-                const { argsDecl, argsCall, vars } = buildConnArgs(opts, filterTypeName);
+                const scopedOpts = connectionField === "issues"
+                    ? { ...opts, filter: mergeIssueScopeFilter(ctx, opts.filter) }
+                    : opts;
+                if (connectionField !== "issues")
+                    requireUnscoped(ctx, name);
+                const { argsDecl, argsCall, vars } = buildConnArgs(scopedOpts, filterTypeName);
                 const declParts = ["$id: String!", argsDecl.slice(1, -1)];
                 const callParts = [argsCall.slice(1, -1)];
                 const includeSubTeamsSet = includeSubTeamsDescription !== undefined && opts.includeSubTeams !== undefined;
@@ -35,24 +41,25 @@ export function registerViewActions(rl) {
     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.",
+        description: "Create a custom view. Set filterData for issue views; projectFilterData, initiativeFilterData, or feedItemFilterData for other view types. Read matches back with view.issues/projects/initiatives/updates.",
         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" })),
+            shared: t.Optional(t.Boolean({ description: "false creates a personal view; true shares the view with the workspace or scoped container" })),
+            filterData: t.Optional(t.Object({}, { description: ISSUE_FILTER_DESCRIPTION })),
             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" })),
+            teamId: t.Optional(t.String({ description: "Scope the view to a team" })),
+            projectId: t.Optional(t.String({ description: "Scope the view to a project-specific view" })),
+            initiativeId: t.Optional(t.String({ description: "Scope the view to an initiative-specific view" })),
+            ownerId: t.Optional(t.String({ description: "Set the user that owns the 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) {
+            requireUnscoped(ctx, "view.create");
             const data = await gql(key(ctx), `mutation($input: CustomViewCreateInput!) { customViewCreate(input: $input) { success customView { ${CUSTOM_VIEW_FIELDS} } } }`, { input: input });
             return data.customViewCreate?.customView;
         },
@@ -65,17 +72,18 @@ export function registerViewActions(rl) {
             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" })),
+            shared: t.Optional(t.Boolean({ description: "false creates a personal view; true shares the view with the workspace or scoped container" })),
+            filterData: t.Optional(t.Object({}, { description: ISSUE_FILTER_DESCRIPTION })),
             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" })),
+            teamId: t.Optional(t.String({ description: "Scope the view to a team" })),
+            projectId: t.Optional(t.String({ description: "Scope the view to a project-specific view" })),
+            initiativeId: t.Optional(t.String({ description: "Scope the view to an initiative-specific view" })),
+            ownerId: t.Optional(t.String({ description: "Set the user that owns the view" })),
         }),
         async execute(input, ctx) {
+            requireUnscoped(ctx, "view.update");
             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;
@@ -85,6 +93,7 @@ export function registerViewActions(rl) {
         description: "Delete a custom view.",
         inputSchema: t.Object({ id: t.String({ description: "The identifier of the custom view to delete" }) }),
         async execute(input, ctx) {
+            requireUnscoped(ctx, "view.delete");
             const data = await gql(key(ctx), `mutation($id: String!) { customViewDelete(id: $id) { success } }`, { id: input.id });
             return data.customViewDelete;
         },

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { WEBHOOK_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+import { WEBHOOK_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } from "./shared.js";
 export function registerWebhookActions(rl) {
     const listAction = bindListAction(rl);
     const getAction = bindGetAction(rl);
@@ -18,6 +18,7 @@ export function registerWebhookActions(rl) {
             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, "webhooks.*");
             const data = await gql(key(ctx), `mutation($input: WebhookCreateInput!) { webhookCreate(input: $input) { success webhook { ${WEBHOOK_FIELDS} } } }`, { input: input });
             return data.webhookCreate?.webhook;
         },
@@ -33,6 +34,7 @@ export function registerWebhookActions(rl) {
             secret: t.Optional(t.String({ description: "A secret token used to sign the webhook payload" })),
         }),
         async execute(input, ctx) {
+            requireUnscoped(ctx, "webhooks.*");
             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;
@@ -42,6 +44,7 @@ export function registerWebhookActions(rl) {
         description: "Delete a webhook.",
         inputSchema: t.Object({ id: t.String({ description: "The identifier of the webhook to delete" }) }),
         async execute(input, ctx) {
+            requireUnscoped(ctx, "webhooks.*");
             const data = await gql(key(ctx), `mutation($id: String!) { webhookDelete(id: $id) { success } }`, { id: input.id });
             return data.webhookDelete;
         },
@@ -50,6 +53,7 @@ export function registerWebhookActions(rl) {
         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) {
+            requireUnscoped(ctx, "webhooks.*");
             const data = await gql(key(ctx), `mutation($id: String!) { webhookRotateSecret(id: $id) { success secret } }`, { id: input.id });
             return data.webhookRotateSecret;
         },

package/dist/plugins/vercel/src/account.js

@@ -0,0 +1,11 @@
+import * as t from "typebox";
+import { TEAM_INPUT_SCHEMA, api } from "./shared.js";
+export function registerAccountActions(rl) {
+    rl.registerAction("whoami", {
+        description: "Validate the Vercel token and return the authenticated user/account context.",
+        inputSchema: t.Object(TEAM_INPUT_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v2/user", { query: (input ?? {}) });
+        },
+    });
+}

package/dist/plugins/vercel/src/deployments.js

@@ -0,0 +1,79 @@
+import * as t from "typebox";
+import { LIST_INPUT_SCHEMA, TEAM_INPUT_SCHEMA, api, bindGetAction } from "./shared.js";
+export function registerDeploymentActions(rl) {
+    const getAction = bindGetAction(rl);
+    rl.registerAction("deployment.list", {
+        description: "List Vercel deployments. Filter by project, state, target, user, or time window.",
+        inputSchema: t.Object({
+            ...LIST_INPUT_SCHEMA,
+            projectId: t.Optional(t.String({ description: "Project ID to filter deployments" })),
+            projectIds: t.Optional(t.Array(t.String(), { description: "Project IDs to filter deployments" })),
+            app: t.Optional(t.String({ description: "Project name/app filter" })),
+            target: t.Optional(t.String({ description: "production, preview, or a custom target" })),
+            state: t.Optional(t.String({ description: "Comma-separated deployment states, e.g. BUILDING,READY,ERROR" })),
+            users: t.Optional(t.String({ description: "Comma-separated Vercel user IDs" })),
+        }),
+        async execute(input, ctx) {
+            return api(ctx, "/v7/deployments", { query: (input ?? {}) });
+        },
+    });
+    getAction("deployment.get", "Get a Vercel deployment by ID or URL.", (id) => `/v13/deployments/${encodeURIComponent(id)}`);
+    rl.registerAction("deployment.logs", {
+        description: "Get build/deployment logs/events for a deployment. Use builds=1 for build logs and limit/since/until to avoid huge responses.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            idOrUrl: t.String({ description: "Deployment ID or URL" }),
+            limit: t.Optional(t.Number({ description: "Maximum events. Vercel supports -1 for all available logs" })),
+            direction: t.Optional(t.String({ description: "forward or backward" })),
+            follow: t.Optional(t.Number({ description: "0 or 1. Avoid 1 in short-lived agent calls unless intentionally streaming" })),
+            name: t.Optional(t.String({ description: "Build ID/name" })),
+            since: t.Optional(t.Number({ description: "Start timestamp in milliseconds" })),
+            until: t.Optional(t.Number({ description: "End timestamp in milliseconds" })),
+            statusCode: t.Optional(t.String({ description: "HTTP status filter such as 5xx" })),
+            delimiter: t.Optional(t.Number({ description: "0 or 1" })),
+            builds: t.Optional(t.Number({ description: "0 or 1" })),
+        }),
+        async execute(input, ctx) {
+            const { idOrUrl, ...query } = input;
+            return api(ctx, `/v3/deployments/${encodeURIComponent(String(idOrUrl))}/events`, { query });
+        },
+    });
+    rl.registerAction("deployment.runtimeLogs", {
+        description: "Get runtime logs for a deployment. Requires projectId and deploymentId; use limit/since/until to keep responses bounded.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectId: t.String({ description: "Project ID" }),
+            deploymentId: t.String({ description: "Deployment ID" }),
+            limit: t.Optional(t.Number({ description: "Maximum logs when supported by Vercel" })),
+            since: t.Optional(t.Number({ description: "Start timestamp in milliseconds" })),
+            until: t.Optional(t.Number({ description: "End timestamp in milliseconds" })),
+        }),
+        async execute(input, ctx) {
+            const { projectId, deploymentId, ...query } = input;
+            return api(ctx, `/v1/projects/${encodeURIComponent(String(projectId))}/deployments/${encodeURIComponent(String(deploymentId))}/runtime-logs`, { query });
+        },
+    });
+    rl.registerAction("deployment.cancel", {
+        description: "Cancel a queued or building Vercel deployment.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            id: t.String({ description: "Deployment ID" }),
+        }),
+        async execute(input, ctx) {
+            const { id, ...query } = input;
+            return api(ctx, `/v12/deployments/${encodeURIComponent(id)}/cancel`, { method: "PATCH", query });
+        },
+    });
+    rl.registerAction("deployment.promote", {
+        description: "Promote an existing deployment to production for a project, where supported by Vercel.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectId: t.String({ description: "Project ID" }),
+            deploymentId: t.String({ description: "Deployment ID to promote" }),
+        }),
+        async execute(input, ctx) {
+            const { projectId, deploymentId, ...query } = input;
+            return api(ctx, `/v10/projects/${encodeURIComponent(String(projectId))}/promote/${encodeURIComponent(String(deploymentId))}`, { method: "POST", query });
+        },
+    });
+}

package/dist/plugins/vercel/src/env.js

@@ -0,0 +1,101 @@
+import * as t from "typebox";
+import { TEAM_INPUT_SCHEMA, api } from "./shared.js";
+const targetSchema = t.Union([t.String(), t.Array(t.String())], {
+    description: "production, preview, development, custom environment, or array of targets",
+});
+function normalizeEnvBody(body) {
+    const normalized = { ...body };
+    if (typeof normalized.target === "string")
+        normalized.target = [normalized.target];
+    return normalized;
+}
+function assertCreateEnvInput(body) {
+    if (!body.key || !body.value || !body.type) {
+        throw new Error("env.set create requires key, value, and type");
+    }
+    if (!body.target && !body.customEnvironmentIds) {
+        throw new Error("env.set create requires target or customEnvironmentIds");
+    }
+}
+export function registerEnvActions(rl) {
+    rl.registerAction("env.list", {
+        description: "List environment variables for a Vercel project.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectIdOrName: t.String({ description: "Project ID or name" }),
+            target: t.Optional(t.String({ description: "production, preview, development, or custom environment" })),
+            gitBranch: t.Optional(t.String({ description: "Git branch filter" })),
+            decrypt: t.Optional(t.Boolean({ description: "Ask Vercel to include decrypted values when permitted" })),
+            source: t.Optional(t.String({ description: "Environment variable source filter" })),
+        }),
+        async execute(input, ctx) {
+            const { projectIdOrName, ...query } = input;
+            return api(ctx, `/v10/projects/${encodeURIComponent(String(projectIdOrName))}/env`, { query });
+        },
+    });
+    rl.registerAction("env.get", {
+        description: "Get one environment variable by ID for a Vercel project, including decrypted value when permitted.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectIdOrName: t.String({ description: "Project ID or name" }),
+            id: t.String({ description: "Environment variable ID" }),
+        }),
+        async execute(input, ctx) {
+            const { projectIdOrName, id, ...query } = input;
+            return api(ctx, `/v1/projects/${encodeURIComponent(String(projectIdOrName))}/env/${encodeURIComponent(String(id))}`, { query });
+        },
+    });
+    rl.registerAction("env.set", {
+        description: "Create or update a Vercel project environment variable. Without id, creates a variable and requires key, value, type, and target/customEnvironmentIds. With id, updates that exact variable. Be explicit about target to avoid changing the wrong environment.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectIdOrName: t.String({ description: "Project ID or name" }),
+            id: t.Optional(t.String({ description: "Environment variable ID. When provided, env.set updates instead of creating." })),
+            key: t.Optional(t.String({ description: "Variable name" })),
+            value: t.Optional(t.String({ description: "Variable value" })),
+            target: t.Optional(targetSchema),
+            customEnvironmentIds: t.Optional(t.Array(t.String(), { description: "Custom environment IDs for custom-environment scoped variables" })),
+            type: t.Optional(t.String({ description: "Vercel env var type: system, encrypted, plain, or sensitive" })),
+            gitBranch: t.Optional(t.String({ description: "Git branch for branch-scoped preview variables" })),
+            comment: t.Optional(t.String({ description: "Optional comment" })),
+            variables: t.Optional(t.Array(t.Object({}, { description: "Raw Vercel env var objects for batch create" }))),
+        }),
+        async execute(input, ctx) {
+            const { projectIdOrName, id, teamId, slug, variables, ...fields } = input;
+            const query = { teamId, slug };
+            if (id) {
+                return api(ctx, `/v9/projects/${encodeURIComponent(String(projectIdOrName))}/env/${encodeURIComponent(String(id))}`, {
+                    method: "PATCH",
+                    query,
+                    body: normalizeEnvBody(fields),
+                });
+            }
+            if (Array.isArray(variables)) {
+                return api(ctx, `/v10/projects/${encodeURIComponent(String(projectIdOrName))}/env`, {
+                    method: "POST",
+                    query,
+                    body: variables.map((item) => normalizeEnvBody(item)),
+                });
+            }
+            const body = normalizeEnvBody(fields);
+            assertCreateEnvInput(body);
+            return api(ctx, `/v10/projects/${encodeURIComponent(String(projectIdOrName))}/env`, { method: "POST", query, body });
+        },
+    });
+    rl.registerAction("env.delete", {
+        description: "Delete an environment variable from a Vercel project. This removes the variable for the specified project/environment scope.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectIdOrName: t.String({ description: "Project ID or name" }),
+            id: t.String({ description: "Environment variable ID" }),
+            customEnvironmentId: t.Optional(t.String({ description: "Custom environment ID when required" })),
+        }),
+        async execute(input, ctx) {
+            const { projectIdOrName, id, customEnvironmentId, ...query } = input;
+            return api(ctx, `/v9/projects/${encodeURIComponent(String(projectIdOrName))}/env/${encodeURIComponent(String(id))}`, {
+                method: "DELETE",
+                query: { ...query, customEnvironmentId },
+            });
+        },
+    });
+}

package/dist/plugins/vercel/src/index.js

@@ -0,0 +1,27 @@
+import * as t from "typebox";
+import { registerAccountActions } from "./account.js";
+import { registerDeploymentActions } from "./deployments.js";
+import { registerEnvActions } from "./env.js";
+import { registerProjectActions } from "./projects.js";
+export default function vercel(rl) {
+    rl.setName("vercel");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        token: t.String({
+            description: "Vercel access token (https://vercel.com/account/settings/tokens)",
+            env: "VERCEL_TOKEN",
+        }),
+        teamId: t.Optional(t.String({
+            description: "Optional Vercel Team ID. Added as teamId to every API request.",
+            env: "VERCEL_TEAM_ID",
+        })),
+        slug: t.Optional(t.String({
+            description: "Optional Vercel Team slug. Added as slug to every API request when teamId is not used.",
+            env: "VERCEL_TEAM_SLUG",
+        })),
+    }));
+    registerAccountActions(rl);
+    registerProjectActions(rl);
+    registerDeploymentActions(rl);
+    registerEnvActions(rl);
+}

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

@@ -0,0 +1,29 @@
+import * as t from "typebox";
+import { LIST_INPUT_SCHEMA, TEAM_INPUT_SCHEMA, api, bindGetAction } from "./shared.js";
+export function registerProjectActions(rl) {
+    const getAction = bindGetAction(rl);
+    rl.registerAction("project.list", {
+        description: "List Vercel projects visible to the token.",
+        inputSchema: t.Object({
+            ...LIST_INPUT_SCHEMA,
+            search: t.Optional(t.String({ description: "Search by project name" })),
+        }),
+        async execute(input, ctx) {
+            const opts = (input ?? {});
+            return api(ctx, "/v10/projects", { query: opts });
+        },
+    });
+    getAction("project.get", "Get a Vercel project by ID or name.", (id) => `/v9/projects/${encodeURIComponent(id)}`);
+    rl.registerAction("project.domains", {
+        description: "List domains configured for a Vercel project.",
+        inputSchema: t.Object({
+            ...TEAM_INPUT_SCHEMA,
+            projectIdOrName: t.String({ description: "Project ID or name" }),
+            limit: t.Optional(t.Number({ description: "Maximum number of domains" })),
+        }),
+        async execute(input, ctx) {
+            const { projectIdOrName, ...query } = input;
+            return api(ctx, `/v9/projects/${encodeURIComponent(String(projectIdOrName))}/domains`, { query });
+        },
+    });
+}