runline 0.11.2 → 0.11.4

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.4",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",