runline 0.8.1 → 0.10.0

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

@@ -0,0 +1,72 @@
+import * as t from "typebox";
+const BASE_URL = "https://api.steel.dev";
+export function apiKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export async function api(ctx, path, options = {}) {
+    const url = new URL(path, BASE_URL);
+    for (const [key, value] of Object.entries(options.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 headers = {
+        "steel-api-key": apiKey(ctx),
+        ...(options.headers ?? {}),
+    };
+    let body;
+    if (options.body !== undefined) {
+        if (options.body instanceof FormData) {
+            body = options.body;
+        }
+        else {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(options.body);
+        }
+    }
+    const res = await fetch(url.toString(), {
+        method: options.method ?? "GET",
+        headers,
+        body,
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`Steel 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 function compactRecord(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null));
+}
+export const LIST_INPUT_SCHEMA = {
+    limit: t.Optional(t.Number({ description: "Maximum number of results when supported" })),
+    cursor: t.Optional(t.String({ description: "Pagination cursor when supported" })),
+};
+export const SESSION_OPTIONS_SCHEMA = {
+    timeout: t.Optional(t.Number({ description: "Session hard timeout in milliseconds" })),
+    inactivityTimeout: t.Optional(t.Number({ description: "Release after this many milliseconds of inactivity" })),
+    useProxy: t.Optional(t.Any({ description: "true for Steel managed proxy, or proxy config object" })),
+    solveCaptcha: t.Optional(t.Boolean({ description: "Enable CAPTCHA detection/solving" })),
+    region: t.Optional(t.String({ description: "Steel region, e.g. lax or iad" })),
+    namespace: t.Optional(t.String({ description: "Credential namespace to use for this session" })),
+    userAgent: t.Optional(t.String({ description: "Custom browser user agent" })),
+    dimensions: t.Optional(t.Any({ description: "Viewport dimensions, e.g. { width: 1280, height: 768 }" })),
+    stealthConfig: t.Optional(t.Any({ description: "Steel stealth configuration, e.g. { autoCaptchaSolving: false }" })),
+    deviceConfig: t.Optional(t.Any({ description: "Device config, e.g. { device: 'mobile' }" })),
+    profileId: t.Optional(t.String({ description: "Profile ID to load" })),
+    persistProfile: t.Optional(t.Boolean({ description: "Persist profile changes on release" })),
+    credentials: t.Optional(t.Any({ description: "Credentials injection options, or {} to enable defaults" })),
+    extensionIds: t.Optional(t.Array(t.String(), { description: "Extension IDs to attach, or ['all_ext']" })),
+    sessionContext: t.Optional(t.Any({ description: "Captured session context to restore" })),
+    isSelenium: t.Optional(t.Boolean({ description: "Provision a Selenium-compatible session" })),
+};

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.1",
+  "version": "0.10.0",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -62,6 +62,14 @@
     "minisearch": "^7.2.0",
     "typescript": "^5.8.0"
   },
+  "peerDependencies": {
+    "playwright": "^1.57.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",