runline 0.11.2 → 0.11.3

package/dist/plugin/loader.js

@@ -55,6 +55,9 @@ export async function loadPluginFromPath(path) {
         : mod;
     return resolvePluginExport(pluginExport, pluginId);
 }
+function isPrivatePluginDirectory(entry) {
+    return entry.startsWith("_") || entry.startsWith(".");
+}
 async function loadFromDirectory(dir) {
     const plugins = [];
     if (!existsSync(dir))
@@ -75,6 +78,8 @@ async function loadFromDirectory(dir) {
             }
         }
         else if (stat.isDirectory()) {
+            if (isPrivatePluginDirectory(entry))
+                continue;
             const candidates = [
                 join(fullPath, "index.ts"),
                 join(fullPath, "index.js"),

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

@@ -34,7 +34,11 @@ export function registerIssueActions(rl) {
     });
     rl.registerAction("issue.get", {
         description: "Get an issue by ID or identifier (e.g. 'THE-154')",
-        inputSchema: t.Object({ issueId: t.String() }),
+        inputSchema: t.Object({
+            issueId: t.String({
+                description: "Required parameter name. Pass either the Linear issue UUID or issue identifier, e.g. 'THE-154'.",
+            }),
+        }),
         async execute(input, ctx) {
             const data = await gql(key(ctx), `query($id: String!) { issue(id: $id) { ${ISSUE_FIELDS} } }`, { id: input.issueId });
             const issue = data.issue;

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

@@ -1,224 +1,38 @@
-const API_VERSION = "v59.0";
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        instanceUrl: c.instanceUrl.replace(/\/$/, ""),
-        accessToken: c.accessToken,
-    };
-}
-async function api(conn, method, endpoint, body, qs) {
-    const url = new URL(`${conn.instanceUrl}/services/data/${API_VERSION}${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
-        method,
-        headers: {
-            Authorization: `Bearer ${conn.accessToken}`,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(url.toString(), init);
-    if (res.status === 204)
-        return { success: true };
-    if (!res.ok)
-        throw new Error(`Salesforce error ${res.status}: ${await res.text()}`);
-    return res.json();
-}
-const SOBJECTS = [
-    "Account",
-    "Contact",
-    "Lead",
-    "Opportunity",
-    "Case",
-    "Task",
-    "User",
-];
-const DEFAULT_FIELDS = {
-    Account: "Id,Name,Type",
-    Contact: "Id,FirstName,LastName,Email",
-    Lead: "Id,Company,FirstName,LastName,Email,Status",
-    Opportunity: "Id,AccountId,Amount,Probability,StageName",
-    Case: "Id,AccountId,ContactId,Priority,Status,Subject",
-    Task: "Id,Subject,Status,Priority",
-    User: "Id,Name,Email",
-};
-function registerSObject(rl, sObject, conn) {
-    const lower = sObject.toLowerCase();
-    rl.registerAction(`${lower}.create`, {
-        description: `Create a ${sObject}`,
-        inputSchema: {
-            data: {
-                type: "object",
-                required: true,
-                description: `${sObject} field values`,
-            },
-        },
-        async execute(input, ctx) {
-            return api(conn(ctx), "POST", `/sobjects/${sObject}`, input.data);
-        },
-    });
-    rl.registerAction(`${lower}.get`, {
-        description: `Get a ${sObject} by ID`,
-        inputSchema: { id: { type: "string", required: true } },
-        async execute(input, ctx) {
-            return api(conn(ctx), "GET", `/sobjects/${sObject}/${input.id}`);
-        },
-    });
-    rl.registerAction(`${lower}.update`, {
-        description: `Update a ${sObject}`,
-        inputSchema: {
-            id: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.id}`, p.data);
-            return { success: true, id: p.id };
-        },
-    });
-    rl.registerAction(`${lower}.delete`, {
-        description: `Delete a ${sObject}`,
-        inputSchema: { id: { type: "string", required: true } },
-        async execute(input, ctx) {
-            await api(conn(ctx), "DELETE", `/sobjects/${sObject}/${input.id}`);
-            return { success: true };
-        },
-    });
-    rl.registerAction(`${lower}.query`, {
-        description: `Query ${sObject}s with SOQL`,
-        inputSchema: {
-            fields: {
-                type: "string",
-                required: false,
-                description: `Comma-separated (default: ${DEFAULT_FIELDS[sObject] ?? "Id"})`,
-            },
-            where: {
-                type: "string",
-                required: false,
-                description: "SOQL WHERE clause",
-            },
-            limit: { type: "number", required: false },
-        },
-        async execute(input, ctx) {
-            const p = (input ?? {});
-            const fields = p.fields || DEFAULT_FIELDS[sObject] || "Id";
-            let q = `SELECT ${fields} FROM ${sObject}`;
-            if (p.where)
-                q += ` WHERE ${p.where}`;
-            if (p.limit)
-                q += ` LIMIT ${p.limit}`;
-            const data = (await api(conn(ctx), "GET", "/query", undefined, {
-                q,
-            }));
-            return data.records;
-        },
-    });
-    rl.registerAction(`${lower}.upsert`, {
-        description: `Upsert a ${sObject} by external ID`,
-        inputSchema: {
-            externalIdField: { type: "string", required: true },
-            externalIdValue: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.externalIdField}/${p.externalIdValue}`, p.data);
-        },
-    });
-}
+import * as t from "typebox";
+import { registerMetadataActions } from "./metadata.js";
+import { registerQueryActions } from "./query.js";
+import { registerGenericSObjectActions, registerStandardSObjectActions } from "./sobjects.js";
 export default function salesforce(rl) {
     rl.setName("salesforce");
-    rl.setVersion("0.1.0");
-    rl.setConnectionSchema({
-        instanceUrl: {
-            type: "string",
-            required: true,
-            description: "Salesforce instance URL (e.g. https://yourorg.my.salesforce.com)",
+    rl.setVersion("0.2.0");
+    rl.setConnectionSchema(t.Object({
+        instanceUrl: t.Optional(t.String({
+            description: "Salesforce API instance URL, e.g. https://your-domain.my.salesforce.com. Required for static accessToken auth; optional for client credentials when loginUrl is set.",
             env: "SALESFORCE_INSTANCE_URL",
-        },
-        accessToken: {
-            type: "string",
-            required: true,
-            description: "Salesforce OAuth2 access token",
+        })),
+        accessToken: t.Optional(t.String({
+            description: "Salesforce OAuth2 access token. Use for static-token auth.",
             env: "SALESFORCE_ACCESS_TOKEN",
-        },
-    });
-    for (const sObject of SOBJECTS) {
-        registerSObject(rl, sObject, getConn);
-    }
-    // ── Generic sObject ─────────────────────────────────
-    rl.registerAction("sobject.create", {
-        description: "Create any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(getConn(ctx), "POST", `/sobjects/${p.sObject}`, p.data);
-        },
-    });
-    rl.registerAction("sobject.get", {
-        description: "Get any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            return api(getConn(ctx), "GET", `/sobjects/${p.sObject}/${p.id}`);
-        },
-    });
-    rl.registerAction("sobject.update", {
-        description: "Update any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-            data: { type: "object", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(getConn(ctx), "PATCH", `/sobjects/${p.sObject}/${p.id}`, p.data);
-            return { success: true };
-        },
-    });
-    rl.registerAction("sobject.delete", {
-        description: "Delete any sObject record",
-        inputSchema: {
-            sObject: { type: "string", required: true },
-            id: { type: "string", required: true },
-        },
-        async execute(input, ctx) {
-            const p = input;
-            await api(getConn(ctx), "DELETE", `/sobjects/${p.sObject}/${p.id}`);
-            return { success: true };
-        },
-    });
-    // ── SOQL Query ──────────────────────────────────────
-    rl.registerAction("soql.query", {
-        description: "Execute a raw SOQL query",
-        inputSchema: {
-            query: { type: "string", required: true, description: "Full SOQL query" },
-        },
-        async execute(input, ctx) {
-            const data = (await api(getConn(ctx), "GET", "/query", undefined, {
-                q: input.query,
-            }));
-            return data.records;
-        },
-    });
-    // ── Describe ────────────────────────────────────────
-    rl.registerAction("sobject.describe", {
-        description: "Describe an sObject's metadata/fields",
-        inputSchema: { sObject: { type: "string", required: true } },
-        async execute(input, ctx) {
-            return api(getConn(ctx), "GET", `/sobjects/${input.sObject}/describe`);
-        },
-    });
+        })),
+        loginUrl: t.Optional(t.String({
+            description: "Salesforce OAuth token host for client credentials, usually your My Domain URL such as https://your-domain.my.salesforce.com.",
+            env: "SALESFORCE_LOGIN_URL",
+        })),
+        clientId: t.Optional(t.String({
+            description: "Salesforce Connected App consumer key for OAuth client credentials flow.",
+            env: "SALESFORCE_CLIENT_ID",
+        })),
+        clientSecret: t.Optional(t.String({
+            description: "Salesforce Connected App consumer secret for OAuth client credentials flow.",
+            env: "SALESFORCE_CLIENT_SECRET",
+        })),
+        apiVersion: t.Optional(t.String({
+            description: "Salesforce REST API version (default v59.0). Accepts vXX.0 or XX.0.",
+            env: "SALESFORCE_API_VERSION",
+        })),
+    }));
+    registerMetadataActions(rl);
+    registerQueryActions(rl);
+    registerStandardSObjectActions(rl);
+    registerGenericSObjectActions(rl);
 }

package/dist/plugins/salesforce/src/metadata.js

@@ -0,0 +1,50 @@
+import * as t from "typebox";
+import { api, getSession, identity } from "./shared.js";
+export function registerMetadataActions(rl) {
+    rl.registerAction("connection.test", {
+        description: "Validate Salesforce auth and return safe connection metadata",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            const sessionPromise = getSession(ctx);
+            const session = await sessionPromise;
+            let limits;
+            let limitsError;
+            try {
+                limits = (await api(ctx, "GET", "/limits", undefined, undefined, sessionPromise));
+            }
+            catch (error) {
+                limitsError = error instanceof Error ? error.message : String(error);
+            }
+            return {
+                ok: true,
+                instanceUrl: session.instanceUrl,
+                tokenType: session.tokenType,
+                scope: session.scope,
+                id: session.id,
+                limits,
+                limitsError,
+            };
+        },
+    });
+    rl.registerAction("auth.identity", {
+        description: "Return the Salesforce OAuth identity for the current connection",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return identity(ctx);
+        },
+    });
+    rl.registerAction("limits.get", {
+        description: "Return Salesforce org REST API limits",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "GET", "/limits");
+        },
+    });
+    rl.registerAction("metadata.objects", {
+        description: "List available Salesforce sObjects and metadata summaries",
+        inputSchema: t.Object({}),
+        async execute(_input, ctx) {
+            return api(ctx, "GET", "/sobjects");
+        },
+    });
+}

package/dist/plugins/salesforce/src/query.js

@@ -0,0 +1,52 @@
+import * as t from "typebox";
+import { records } from "./queryResult.js";
+import { api, rest } from "./shared.js";
+const QueryInput = t.Object({
+    query: t.String({ description: "Full SOQL query" }),
+});
+async function queryPage(ctx, endpoint, query) {
+    return (await api(ctx, "GET", endpoint, undefined, {
+        q: query,
+    }));
+}
+export function registerQueryActions(rl) {
+    rl.registerAction("soql.query", {
+        description: "Execute a raw SOQL query and return the first page of records",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return records(await queryPage(ctx, "/query", input.query));
+        },
+    });
+    rl.registerAction("soql.queryPage", {
+        description: "Execute a raw SOQL query and return Salesforce pagination metadata",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return queryPage(ctx, "/query", input.query);
+        },
+    });
+    rl.registerAction("soql.queryAll", {
+        description: "Execute a raw SOQL query including deleted and archived records; returns the first page of records",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return records(await queryPage(ctx, "/queryAll", input.query));
+        },
+    });
+    rl.registerAction("soql.queryAllPage", {
+        description: "Execute a raw SOQL query including deleted and archived records and return Salesforce pagination metadata",
+        inputSchema: QueryInput,
+        async execute(input, ctx) {
+            return queryPage(ctx, "/queryAll", input.query);
+        },
+    });
+    rl.registerAction("soql.nextPage", {
+        description: "Fetch the next page from a Salesforce nextRecordsUrl returned by soql.queryPage or soql.queryAllPage",
+        inputSchema: t.Object({
+            nextRecordsUrl: t.String({
+                description: "Salesforce nextRecordsUrl, e.g. /services/data/v59.0/query/01g...",
+            }),
+        }),
+        async execute(input, ctx) {
+            return rest(ctx, "GET", input.nextRecordsUrl);
+        },
+    });
+}

package/dist/plugins/salesforce/src/queryResult.js

@@ -0,0 +1,4 @@
+export function records(data) {
+    const value = data.records;
+    return Array.isArray(value) ? value : [];
+}

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

@@ -0,0 +1,122 @@
+export const DEFAULT_API_VERSION = "v59.0";
+export function config(ctx) {
+    return ctx.connection.config;
+}
+export function trimTrailingSlash(url) {
+    return url.replace(/\/+$/, "");
+}
+function requireString(value, name) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Salesforce connection is missing ${name}`);
+    }
+    return value.trim();
+}
+export function apiVersion(ctx) {
+    const raw = config(ctx).apiVersion;
+    if (typeof raw !== "string" || raw.trim() === "")
+        return DEFAULT_API_VERSION;
+    const version = raw.trim();
+    return version.startsWith("v") ? version : `v${version}`;
+}
+export function validateInstanceUrl(url) {
+    const normalized = trimTrailingSlash(url.trim());
+    if (/\.lightning\.force\.com$/i.test(new URL(normalized).hostname)) {
+        throw new Error("Salesforce instanceUrl/loginUrl must be the API My Domain URL, not the Lightning UI URL. Use a URL like https://your-domain.my.salesforce.com.");
+    }
+    return normalized;
+}
+export async function getSession(ctx) {
+    const c = config(ctx);
+    if (c.accessToken) {
+        return {
+            instanceUrl: validateInstanceUrl(requireString(c.instanceUrl, "instanceUrl")),
+            accessToken: requireString(c.accessToken, "accessToken"),
+            tokenType: "Bearer",
+        };
+    }
+    const loginUrl = validateInstanceUrl(requireString(c.loginUrl ?? c.instanceUrl, "loginUrl or instanceUrl"));
+    const clientId = requireString(c.clientId, "clientId");
+    const clientSecret = requireString(c.clientSecret, "clientSecret");
+    const body = new URLSearchParams();
+    body.set("grant_type", "client_credentials");
+    body.set("client_id", clientId);
+    body.set("client_secret", clientSecret);
+    const res = await fetch(`${loginUrl}/services/oauth2/token`, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body,
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!res.ok) {
+        const err = typeof data.error === "string" ? data.error : res.status;
+        const description = typeof data.error_description === "string"
+            ? `: ${data.error_description}`
+            : "";
+        throw new Error(`Salesforce token error ${err}${description}`);
+    }
+    return {
+        instanceUrl: validateInstanceUrl(requireString(data.instance_url, "token response instance_url")),
+        accessToken: requireString(data.access_token, "token response access_token"),
+        tokenType: typeof data.token_type === "string" ? data.token_type : "Bearer",
+        scope: typeof data.scope === "string" ? data.scope : undefined,
+        id: typeof data.id === "string" ? data.id : undefined,
+        issuedAt: typeof data.issued_at === "string" ? data.issued_at : undefined,
+    };
+}
+export async function api(ctx, method, endpoint, body, qs, session = getSession(ctx)) {
+    return rest(ctx, method, `/services/data/${apiVersion(ctx)}${endpoint}`, body, qs, session);
+}
+export async function rest(ctx, method, path, body, qs, session = getSession(ctx)) {
+    const resolvedSession = await session;
+    const url = new URL(path, resolvedSession.instanceUrl);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: {
+            Authorization: `Bearer ${resolvedSession.accessToken}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (res.status === 204)
+        return { success: true };
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`Salesforce error ${res.status}: ${text}`);
+    return text ? JSON.parse(text) : null;
+}
+export async function identity(ctx) {
+    const session = await getSession(ctx);
+    if (!session.id) {
+        return { instanceUrl: session.instanceUrl, tokenType: session.tokenType };
+    }
+    const res = await fetch(session.id, {
+        headers: {
+            Authorization: `Bearer ${session.accessToken}`,
+            Accept: "application/json",
+        },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`Salesforce identity error ${res.status}: ${text}`);
+    }
+    return text ? JSON.parse(text) : {};
+}

package/dist/plugins/salesforce/src/sobjects.js

@@ -0,0 +1,152 @@
+import * as t from "typebox";
+import { records } from "./queryResult.js";
+import { api } from "./shared.js";
+export const SOBJECTS = [
+    "Account",
+    "Contact",
+    "Lead",
+    "Opportunity",
+    "Case",
+    "Task",
+    "User",
+];
+export const DEFAULT_FIELDS = {
+    Account: "Id,Name,Type",
+    Contact: "Id,FirstName,LastName,Email",
+    Lead: "Id,Company,FirstName,LastName,Email,Status",
+    Opportunity: "Id,AccountId,Amount,Probability,StageName",
+    Case: "Id,AccountId,ContactId,Priority,Status,Subject",
+    Task: "Id,Subject,Status,Priority",
+    User: "Id,Name,Email",
+};
+const Data = t.Record(t.String(), t.Unknown(), {
+    description: "Salesforce field values",
+});
+const QueryInput = (sObject) => t.Object({
+    fields: t.Optional(t.String({
+        description: `Comma-separated fields (default: ${DEFAULT_FIELDS[sObject] ?? "Id"})`,
+    })),
+    where: t.Optional(t.String({ description: "SOQL WHERE clause" })),
+    limit: t.Optional(t.Number({ description: "Max records" })),
+});
+function buildQuery(sObject, input) {
+    const p = (input ?? {});
+    const fields = p.fields || DEFAULT_FIELDS[sObject] || "Id";
+    let q = `SELECT ${fields} FROM ${sObject}`;
+    if (p.where)
+        q += ` WHERE ${p.where}`;
+    if (p.limit)
+        q += ` LIMIT ${p.limit}`;
+    return q;
+}
+function registerSObject(rl, sObject) {
+    const lower = sObject.toLowerCase();
+    rl.registerAction(`${lower}.create`, {
+        description: `Create a ${sObject}`,
+        inputSchema: t.Object({ data: Data }),
+        async execute(input, ctx) {
+            return api(ctx, "POST", `/sobjects/${sObject}`, input.data);
+        },
+    });
+    rl.registerAction(`${lower}.get`, {
+        description: `Get a ${sObject} by ID`,
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, "GET", `/sobjects/${sObject}/${input.id}`);
+        },
+    });
+    rl.registerAction(`${lower}.update`, {
+        description: `Update a ${sObject}`,
+        inputSchema: t.Object({ id: t.String(), data: Data }),
+        async execute(input, ctx) {
+            const p = input;
+            await api(ctx, "PATCH", `/sobjects/${sObject}/${p.id}`, p.data);
+            return { success: true, id: p.id };
+        },
+    });
+    rl.registerAction(`${lower}.delete`, {
+        description: `Delete a ${sObject}`,
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            await api(ctx, "DELETE", `/sobjects/${sObject}/${input.id}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction(`${lower}.query`, {
+        description: `Query ${sObject}s with SOQL`,
+        inputSchema: QueryInput(sObject),
+        async execute(input, ctx) {
+            return records(await api(ctx, "GET", "/query", undefined, {
+                q: buildQuery(sObject, input),
+            }));
+        },
+    });
+    rl.registerAction(`${lower}.queryPage`, {
+        description: `Query ${sObject}s with SOQL and return Salesforce pagination metadata`,
+        inputSchema: QueryInput(sObject),
+        async execute(input, ctx) {
+            return api(ctx, "GET", "/query", undefined, {
+                q: buildQuery(sObject, input),
+            });
+        },
+    });
+    rl.registerAction(`${lower}.upsert`, {
+        description: `Upsert a ${sObject} by external ID`,
+        inputSchema: t.Object({
+            externalIdField: t.String(),
+            externalIdValue: t.String(),
+            data: Data,
+        }),
+        async execute(input, ctx) {
+            const p = input;
+            return api(ctx, "PATCH", `/sobjects/${sObject}/${p.externalIdField}/${p.externalIdValue}`, p.data);
+        },
+    });
+}
+export function registerStandardSObjectActions(rl) {
+    for (const sObject of SOBJECTS)
+        registerSObject(rl, sObject);
+}
+export function registerGenericSObjectActions(rl) {
+    rl.registerAction("sobject.create", {
+        description: "Create any sObject record",
+        inputSchema: t.Object({ sObject: t.String(), data: Data }),
+        async execute(input, ctx) {
+            const p = input;
+            return api(ctx, "POST", `/sobjects/${p.sObject}`, p.data);
+        },
+    });
+    rl.registerAction("sobject.get", {
+        description: "Get any sObject record",
+        inputSchema: t.Object({ sObject: t.String(), id: t.String() }),
+        async execute(input, ctx) {
+            const p = input;
+            return api(ctx, "GET", `/sobjects/${p.sObject}/${p.id}`);
+        },
+    });
+    rl.registerAction("sobject.update", {
+        description: "Update any sObject record",
+        inputSchema: t.Object({ sObject: t.String(), id: t.String(), data: Data }),
+        async execute(input, ctx) {
+            const p = input;
+            await api(ctx, "PATCH", `/sobjects/${p.sObject}/${p.id}`, p.data);
+            return { success: true };
+        },
+    });
+    rl.registerAction("sobject.delete", {
+        description: "Delete any sObject record",
+        inputSchema: t.Object({ sObject: t.String(), id: t.String() }),
+        async execute(input, ctx) {
+            const p = input;
+            await api(ctx, "DELETE", `/sobjects/${p.sObject}/${p.id}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("sobject.describe", {
+        description: "Describe an sObject's metadata/fields",
+        inputSchema: t.Object({ sObject: t.String() }),
+        async execute(input, ctx) {
+            return api(ctx, "GET", `/sobjects/${input.sObject}/describe`);
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",