runline 0.8.0 → 0.9.0

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

@@ -0,0 +1,105 @@
+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, 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);
+    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 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;
+                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. 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: "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: "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;
+        },
+    });
+    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: "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: "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;
+        },
+    });
+    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) {
+            requireUnscoped(ctx, "view.delete");
+            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,61 @@
+import * as t from "typebox";
+import { WEBHOOK_FIELDS, bindGetAction, bindListAction, gql, key, requireUnscoped } 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) {
+            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;
+        },
+    });
+    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) {
+            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;
+        },
+    });
+    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) {
+            requireUnscoped(ctx, "webhooks.*");
+            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) {
+            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 });
+        },
+    });
+}

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

@@ -0,0 +1,73 @@
+import * as t from "typebox";
+const BASE_URL = "https://api.vercel.com";
+export function token(ctx) {
+    return ctx.connection.config.token;
+}
+export async function api(ctx, path, options = {}) {
+    const url = new URL(path, BASE_URL);
+    const query = {
+        teamId: ctx.connection.config.teamId,
+        slug: ctx.connection.config.slug,
+        ...(options.query ?? {}),
+    };
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null || value === "")
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const init = {
+        method: options.method ?? "GET",
+        headers: {
+            Authorization: `Bearer ${token(ctx)}`,
+            "Content-Type": "application/json",
+            ...(options.headers ?? {}),
+        },
+    };
+    if (options.body !== undefined)
+        init.body = JSON.stringify(options.body);
+    const res = await fetch(url.toString(), init);
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`Vercel API error ${res.status}: ${text || res.statusText}`);
+    }
+    if (!text)
+        return {};
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json") || text.startsWith("{") || text.startsWith("[")) {
+        return JSON.parse(text);
+    }
+    return text;
+}
+export const TEAM_INPUT_SCHEMA = {
+    teamId: t.Optional(t.String({ description: "Override the configured Vercel Team ID for this call" })),
+    slug: t.Optional(t.String({ description: "Override the configured Vercel Team slug for this call" })),
+};
+export const LIST_INPUT_SCHEMA = {
+    ...TEAM_INPUT_SCHEMA,
+    limit: t.Optional(t.Number({ description: "Maximum number of results" })),
+    since: t.Optional(t.Number({ description: "Timestamp in milliseconds to start from" })),
+    until: t.Optional(t.Number({ description: "Timestamp in milliseconds to end at" })),
+    from: t.Optional(t.Number({ description: "Pagination timestamp/cursor supported by Vercel" })),
+    to: t.Optional(t.Number({ description: "Pagination timestamp/cursor supported by Vercel" })),
+};
+export function bindGetAction(rl) {
+    return (name, description, pathForId) => {
+        rl.registerAction(name, {
+            description,
+            inputSchema: t.Object({
+                id: t.String({ description: "Resource ID, name, or URL" }),
+                ...TEAM_INPUT_SCHEMA,
+            }),
+            async execute(input, ctx) {
+                const { id, ...query } = input;
+                return api(ctx, pathForId(id), { query });
+            },
+        });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "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"
   }
 }