runline 0.8.1 → 0.10.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/steel/src/browser.js

@@ -0,0 +1,175 @@
+import * as t from "typebox";
+import { SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+const SCRAPE_SCHEMA = {
+    url: t.String({ description: "URL to scrape" }),
+    format: t.Optional(t.Array(t.String(), { description: "Formats: html, cleaned_html, markdown, readability" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+    screenshot: t.Optional(t.Boolean({ description: "Also capture a screenshot URL" })),
+    pdf: t.Optional(t.Boolean({ description: "Also capture a PDF URL" })),
+};
+const SCREENSHOT_SCHEMA = {
+    url: t.String({ description: "URL to screenshot" }),
+    fullPage: t.Optional(t.Boolean({ description: "Capture full scrollable page" })),
+    delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+    useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+};
+async function scrape(input, ctx) {
+    return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(input) });
+}
+async function screenshot(input, ctx) {
+    return api(ctx, "/v1/screenshot", { method: "POST", body: compactRecord(input) });
+}
+async function connectMiniCdp(cdpUrl) {
+    const ws = new WebSocket(cdpUrl);
+    let nextId = 0;
+    const pending = new Map();
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("CDP websocket connection timed out")), 30000);
+        ws.addEventListener("open", () => { clearTimeout(timer); resolve(); }, { once: true });
+        ws.addEventListener("error", () => { clearTimeout(timer); reject(new Error("CDP websocket connection failed")); }, { once: true });
+    });
+    ws.addEventListener("message", (event) => {
+        let message;
+        try {
+            message = JSON.parse(String(event.data));
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const wait = pending.get(message.id);
+        if (!wait)
+            return;
+        pending.delete(message.id);
+        if (message.error)
+            wait.reject(new Error(JSON.stringify(message.error)));
+        else
+            wait.resolve(message.result);
+    });
+    const send = (method, params = {}, sessionId) => new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+        setTimeout(() => {
+            if (pending.delete(id))
+                reject(new Error(`CDP ${method} timed out`));
+        }, 30000);
+    });
+    const targets = await send("Target.getTargets");
+    const target = targets.targetInfos?.find((info) => info.type === "page") ?? targets.targetInfos?.[0];
+    if (!target)
+        throw new Error("Steel CDP session has no browser target");
+    const attached = await send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
+    const sid = attached.sessionId;
+    const evaluate = async (expression) => {
+        const result = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true }, sid);
+        return result.result?.value;
+    };
+    const page = {
+        async goto(url, _options) {
+            await send("Page.navigate", { url }, sid);
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            return null;
+        },
+        title: () => evaluate("document.title"),
+        url: () => evaluate("location.href"),
+        text: () => evaluate("document.body?.innerText ?? ''"),
+        html: () => evaluate("document.documentElement?.outerHTML ?? ''"),
+        evaluate: (expression) => evaluate(`(${expression})()`),
+    };
+    return { page, browser: { close: () => ws.close() }, context: {}, close: () => ws.close() };
+}
+export function registerBrowserActions(rl) {
+    rl.registerAction("scrape", {
+        description: "One-shot Steel scrape. Loads a URL and returns requested formats such as markdown, html, cleaned_html, or readability.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("browser.scrape", {
+        description: "Backward-compatible alias for scrape.",
+        inputSchema: t.Object(SCRAPE_SCHEMA),
+        execute: scrape,
+    });
+    rl.registerAction("screenshot", {
+        description: "One-shot Steel screenshot. Returns a hosted PNG URL.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.screenshot", {
+        description: "Backward-compatible alias for screenshot.",
+        inputSchema: t.Object(SCREENSHOT_SCHEMA),
+        execute: screenshot,
+    });
+    rl.registerAction("browser.extract", {
+        description: "Fetch a page through Steel scrape and return selected content fields. Use selectors with browser.run for DOM-specific extraction.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to scrape" }),
+            format: t.Optional(t.Array(t.String(), { description: "Formats to request; defaults to markdown and html" })),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            const body = { format: ["markdown", "html"], ...input };
+            return api(ctx, "/v1/scrape", { method: "POST", body: compactRecord(body) });
+        },
+    });
+    rl.registerAction("pdf", {
+        description: "One-shot Steel PDF capture. Returns a hosted PDF URL.",
+        inputSchema: t.Object({
+            url: t.String({ description: "URL to render as PDF" }),
+            delay: t.Optional(t.Number({ description: "Milliseconds to wait after navigation" })),
+            useProxy: t.Optional(t.Any({ description: "true or proxy config" })),
+        }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/pdf", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("browser.run", {
+        description: "Create a Steel session, connect with Playwright over CDP, run an async JavaScript script, then release by default. The script receives { page, browser, context, session }. Requires the host app to have playwright installed.",
+        inputSchema: t.Object({
+            script: t.String({ description: "Async JavaScript body. Example: await page.goto('https://example.com'); return { title: await page.title() };" }),
+            release: t.Optional(t.Boolean({ description: "Release the Steel session after the script finishes (default true)" })),
+            ...SESSION_OPTIONS_SCHEMA,
+        }),
+        async execute(input, ctx) {
+            const { script, release, ...sessionOptions } = input;
+            let playwright;
+            try {
+                playwright = await import("playwright");
+            }
+            catch (_error) {
+                throw new Error("steel.browser.run requires the host project to install playwright. Install playwright or use session.create + session.cdpUrl instead.");
+            }
+            const session = await api(ctx, "/v1/sessions", { method: "POST", body: compactRecord(sessionOptions) });
+            const cdpUrl = `wss://connect.steel.dev?apiKey=${encodeURIComponent(apiKey(ctx))}&sessionId=${encodeURIComponent(String(session.id))}`;
+            let browser;
+            try {
+                let context;
+                let page;
+                try {
+                    const playwrightBrowser = await playwright.chromium.connectOverCDP(cdpUrl, { timeout: 30000 });
+                    browser = playwrightBrowser;
+                    context = playwrightBrowser.contexts()[0] ?? await playwrightBrowser.newContext();
+                    page = context.pages()[0] ?? await context.newPage();
+                }
+                catch {
+                    const mini = await connectMiniCdp(cdpUrl);
+                    browser = mini.browser;
+                    context = mini.context;
+                    page = mini.page;
+                }
+                const fn = new Function("page", "browser", "context", "session", `return (async () => {\n${script}\n})();`);
+                const result = await fn(page, browser, context, session);
+                return { session, result };
+            }
+            finally {
+                await browser?.close()?.catch?.(() => { });
+                if (release !== false && session.id) {
+                    await api(ctx, `/v1/sessions/${encodeURIComponent(String(session.id))}/release`, { method: "POST" }).catch(() => { });
+                }
+            }
+        },
+    });
+}

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

@@ -0,0 +1,19 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+export function registerCaptchaActions(rl) {
+    rl.registerAction("captcha.status", {
+        description: "Get CAPTCHA detection/solving status for a Steel session.",
+        inputSchema: t.Object({ sessionId: t.String() }),
+        async execute(input, ctx) { return api(ctx, `/v1/sessions/${encodeURIComponent(input.sessionId)}/captchas/status`); },
+    });
+    rl.registerAction("captcha.solve", {
+        description: "Trigger CAPTCHA solving for all detected CAPTCHAs or a specific task/url/page.",
+        inputSchema: t.Object({ sessionId: t.String(), taskId: t.Optional(t.String()), url: t.Optional(t.String()), pageId: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve`, { method: "POST", body: compactRecord(body) }); },
+    });
+    rl.registerAction("captcha.solveImage", {
+        description: "Solve an image CAPTCHA by XPath selectors.",
+        inputSchema: t.Object({ sessionId: t.String(), imageXPath: t.String(), inputXPath: t.String(), url: t.Optional(t.String()) }),
+        async execute(input, ctx) { const { sessionId, ...body } = input; return api(ctx, `/v1/sessions/${encodeURIComponent(String(sessionId))}/captchas/solve-image`, { method: "POST", body: compactRecord(body) }); },
+    });
+}

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

@@ -0,0 +1,38 @@
+import * as t from "typebox";
+import { api, compactRecord } from "./shared.js";
+const CREDENTIAL_KEY_SCHEMA = {
+    origin: t.String({ description: "Credential origin" }),
+    namespace: t.Optional(t.String({ description: "Credential namespace (defaults to Steel default)" })),
+};
+export function registerCredentialActions(rl) {
+    rl.registerAction("credential.list", {
+        description: "List Steel credentials. Filter by origin and/or namespace.",
+        inputSchema: t.Object({ namespace: t.Optional(t.String()), origin: t.Optional(t.String()) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { query: input });
+        },
+    });
+    rl.registerAction("credential.create", {
+        description: "Create a Steel credential for an origin/namespace. Value may include username, password, and totpSecret.",
+        inputSchema: t.Object({ ...CREDENTIAL_KEY_SCHEMA, value: t.Any({ description: "Credential payload" }) }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "POST", body: compactRecord(input) });
+        },
+    });
+    rl.registerAction("credential.get", {
+        description: "Retrieve credential metadata by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            const result = await api(ctx, "/v1/credentials", { query: compactRecord(input) });
+            const credentials = result.credentials;
+            return Array.isArray(credentials) ? (credentials[0] ?? null) : null;
+        },
+    });
+    rl.registerAction("credential.delete", {
+        description: "Delete a Steel credential by origin and optional namespace.",
+        inputSchema: t.Object(CREDENTIAL_KEY_SCHEMA),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/credentials", { method: "DELETE", body: compactRecord(input) });
+        },
+    });
+}

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

@@ -0,0 +1,46 @@
+import * as t from "typebox";
+import { api } from "./shared.js";
+function extensionForm(input) {
+    const form = new FormData();
+    if (input.url !== undefined && input.url !== null)
+        form.set("url", String(input.url));
+    return form;
+}
+export function registerExtensionActions(rl) {
+    rl.registerAction("extension.list", {
+        description: "List Steel Chrome extensions installed for the organization.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions");
+        },
+    });
+    rl.registerAction("extension.upload", {
+        description: "Upload an extension from a Chrome Web Store URL. Raw zip/crx uploads should use the API directly.",
+        inputSchema: t.Object({ url: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "POST", body: extensionForm(input) });
+        },
+    });
+    rl.registerAction("extension.update", {
+        description: "Update an extension from a Chrome Web Store URL.",
+        inputSchema: t.Object({ id: t.String(), url: t.String() }),
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(ctx, `/v1/extensions/${encodeURIComponent(String(id))}`, { method: "PUT", body: extensionForm(body) });
+        },
+    });
+    rl.registerAction("extension.delete", {
+        description: "Delete an extension by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, `/v1/extensions/${encodeURIComponent(input.id)}`, { method: "DELETE" });
+        },
+    });
+    rl.registerAction("extension.deleteAll", {
+        description: "Delete all organization extensions.",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "/v1/extensions", { method: "DELETE" });
+        },
+    });
+}