runline 0.1.0

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

@@ -0,0 +1,80 @@
+const BASE_URL = "https://api.brandfetch.io/v2";
+async function apiRequest(apiKey, domain) {
+    const res = await fetch(`${BASE_URL}/brands/${domain}`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Brandfetch API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function brandfetch(rl) {
+    rl.setName("brandfetch");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Brandfetch API key",
+            env: "BRANDFETCH_API_KEY",
+        },
+    });
+    rl.registerAction("brand.getLogos", {
+        description: "Get a company's logos and icons",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain (e.g. nike.com)" },
+        },
+        async execute(input, ctx) {
+            const { domain } = input;
+            const data = await apiRequest(getKey(ctx), domain);
+            return data.logos;
+        },
+    });
+    rl.registerAction("brand.getColors", {
+        description: "Get a company's brand colors",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain" },
+        },
+        async execute(input, ctx) {
+            const { domain } = input;
+            const data = await apiRequest(getKey(ctx), domain);
+            return data.colors;
+        },
+    });
+    rl.registerAction("brand.getFonts", {
+        description: "Get a company's fonts",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain" },
+        },
+        async execute(input, ctx) {
+            const { domain } = input;
+            const data = await apiRequest(getKey(ctx), domain);
+            return data.fonts;
+        },
+    });
+    rl.registerAction("brand.getCompany", {
+        description: "Get a company's data (name, description, etc.)",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain" },
+        },
+        async execute(input, ctx) {
+            const { domain } = input;
+            const data = await apiRequest(getKey(ctx), domain);
+            return data.company;
+        },
+    });
+    rl.registerAction("brand.getIndustry", {
+        description: "Get a company's industry classification",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain" },
+        },
+        async execute(input, ctx) {
+            const { domain } = input;
+            return apiRequest(getKey(ctx), domain);
+        },
+    });
+}

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

@@ -0,0 +1,305 @@
+const BASE_URL = "https://api.brevo.com";
+async function apiRequest(apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "api-key": apiKey,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Brevo API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function brevo(rl) {
+    rl.setName("brevo");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Brevo (Sendinblue) API key",
+            env: "BREVO_API_KEY",
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Contact email" },
+            attributes: { type: "object", required: false, description: "Contact attributes as key-value pairs" },
+            listIds: { type: "array", required: false, description: "Array of list IDs to add contact to" },
+        },
+        async execute(input, ctx) {
+            const { email, attributes, listIds } = (input ?? {});
+            const body = { email };
+            if (attributes)
+                body.attributes = attributes;
+            if (listIds)
+                body.listIds = listIds;
+            return apiRequest(getKey(ctx), "POST", "/v3/contacts", body);
+        },
+    });
+    rl.registerAction("contact.upsert", {
+        description: "Create or update a contact",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Contact email" },
+            attributes: { type: "object", required: false, description: "Contact attributes" },
+            listIds: { type: "array", required: false, description: "List IDs" },
+        },
+        async execute(input, ctx) {
+            const { email, attributes, listIds } = (input ?? {});
+            const body = { email, updateEnabled: true };
+            if (attributes)
+                body.attributes = attributes;
+            if (listIds)
+                body.listIds = listIds;
+            return apiRequest(getKey(ctx), "POST", "/v3/contacts", body);
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by email or ID",
+        inputSchema: {
+            identifier: { type: "string", required: true, description: "Email or contact ID" },
+        },
+        async execute(input, ctx) {
+            const { identifier } = input;
+            return apiRequest(getKey(ctx), "GET", `/v3/contacts/${encodeURIComponent(identifier)}`);
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 50, max: 1000)" },
+            offset: { type: "number", required: false, description: "Offset for pagination" },
+            sort: { type: "string", required: false, description: "Sort order: asc or desc" },
+            modifiedSince: { type: "string", required: false, description: "Filter by modification date (ISO 8601)" },
+        },
+        async execute(input, ctx) {
+            const { limit, offset, sort, modifiedSince } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (offset)
+                qs.offset = offset;
+            if (sort)
+                qs.sort = sort;
+            if (modifiedSince)
+                qs.modifiedSince = modifiedSince;
+            const data = (await apiRequest(getKey(ctx), "GET", "/v3/contacts", undefined, qs));
+            return data.contacts ?? [];
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            identifier: { type: "string", required: true, description: "Email or contact ID" },
+            attributes: { type: "object", required: false, description: "Attributes to update" },
+            listIds: { type: "array", required: false, description: "List IDs to add" },
+            unlinkListIds: { type: "array", required: false, description: "List IDs to remove" },
+        },
+        async execute(input, ctx) {
+            const { identifier, attributes, listIds, unlinkListIds } = input;
+            const body = {};
+            if (attributes)
+                body.attributes = attributes;
+            if (listIds)
+                body.listIds = listIds;
+            if (unlinkListIds)
+                body.unlinkListIds = unlinkListIds;
+            await apiRequest(getKey(ctx), "PUT", `/v3/contacts/${encodeURIComponent(identifier)}`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: {
+            identifier: { type: "string", required: true, description: "Email or contact ID" },
+        },
+        async execute(input, ctx) {
+            const { identifier } = input;
+            await apiRequest(getKey(ctx), "DELETE", `/v3/contacts/${encodeURIComponent(identifier)}`);
+            return { success: true };
+        },
+    });
+    // ── Attribute ───────────────────────────────────────
+    rl.registerAction("attribute.create", {
+        description: "Create a contact attribute",
+        inputSchema: {
+            category: { type: "string", required: true, description: "Category: normal, transactional, category, calculated, global" },
+            name: { type: "string", required: true, description: "Attribute name" },
+            type: { type: "string", required: false, description: "Type (for normal): text, date, float, boolean" },
+            value: { type: "string", required: false, description: "Value (for calculated/global)" },
+            enumeration: { type: "array", required: false, description: "Array of {value, label} for category type" },
+        },
+        async execute(input, ctx) {
+            const { category, name, type, value, enumeration } = input;
+            const body = {};
+            if (type)
+                body.type = type;
+            if (value)
+                body.value = value;
+            if (enumeration)
+                body.enumeration = enumeration;
+            await apiRequest(getKey(ctx), "POST", `/v3/contacts/attributes/${category}/${encodeURIComponent(name)}`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("attribute.update", {
+        description: "Update a contact attribute",
+        inputSchema: {
+            category: { type: "string", required: true, description: "Category: calculated, category, global" },
+            name: { type: "string", required: true, description: "Attribute name" },
+            value: { type: "string", required: false, description: "New value" },
+            enumeration: { type: "array", required: false, description: "Array of {value, label}" },
+        },
+        async execute(input, ctx) {
+            const { category, name, value, enumeration } = input;
+            const body = {};
+            if (value)
+                body.value = value;
+            if (enumeration)
+                body.enumeration = enumeration;
+            return apiRequest(getKey(ctx), "PUT", `/v3/contacts/attributes/${category}/${encodeURIComponent(name)}`, body);
+        },
+    });
+    rl.registerAction("attribute.delete", {
+        description: "Delete a contact attribute",
+        inputSchema: {
+            category: { type: "string", required: true, description: "Category" },
+            name: { type: "string", required: true, description: "Attribute name" },
+        },
+        async execute(input, ctx) {
+            const { category, name } = input;
+            await apiRequest(getKey(ctx), "DELETE", `/v3/contacts/attributes/${category}/${encodeURIComponent(name)}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("attribute.list", {
+        description: "List all contact attributes",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await apiRequest(getKey(ctx), "GET", "/v3/contacts/attributes"));
+            const attrs = data.attributes ?? [];
+            if (limit)
+                return attrs.slice(0, limit);
+            return attrs;
+        },
+    });
+    // ── Email ───────────────────────────────────────────
+    rl.registerAction("email.send", {
+        description: "Send a transactional email",
+        inputSchema: {
+            sender: { type: "string", required: true, description: "Sender email address" },
+            to: { type: "array", required: true, description: "Array of recipient emails (or {email, name} objects)" },
+            subject: { type: "string", required: true, description: "Email subject" },
+            htmlContent: { type: "string", required: false, description: "HTML body" },
+            textContent: { type: "string", required: false, description: "Plain text body" },
+            cc: { type: "array", required: false, description: "CC recipients" },
+            bcc: { type: "array", required: false, description: "BCC recipients" },
+            tags: { type: "array", required: false, description: "Email tags" },
+        },
+        async execute(input, ctx) {
+            const { sender, to, subject, htmlContent, textContent, cc, bcc, tags } = input;
+            const toList = to.map((r) => typeof r === "string" ? { email: r } : r);
+            const senderObj = typeof sender === "string" ? { email: sender } : sender;
+            const body = {
+                sender: senderObj,
+                to: toList,
+                subject,
+            };
+            if (htmlContent)
+                body.htmlContent = htmlContent;
+            if (textContent)
+                body.textContent = textContent;
+            if (cc)
+                body.cc = cc.map((r) => (typeof r === "string" ? { email: r } : r));
+            if (bcc)
+                body.bcc = bcc.map((r) => (typeof r === "string" ? { email: r } : r));
+            if (tags)
+                body.tags = tags;
+            return apiRequest(getKey(ctx), "POST", "/v3/smtp/email", body);
+        },
+    });
+    rl.registerAction("email.sendTemplate", {
+        description: "Send an email using a template",
+        inputSchema: {
+            templateId: { type: "number", required: true, description: "Template ID" },
+            to: { type: "array", required: true, description: "Array of recipient emails (or {email, name} objects)" },
+            params: { type: "object", required: false, description: "Template parameters as key-value pairs" },
+            tags: { type: "array", required: false, description: "Email tags" },
+        },
+        async execute(input, ctx) {
+            const { templateId, to, params, tags } = input;
+            const toList = to.map((r) => typeof r === "string" ? { email: r } : r);
+            const body = { templateId, to: toList };
+            if (params)
+                body.params = params;
+            if (tags)
+                body.tags = tags;
+            return apiRequest(getKey(ctx), "POST", "/v3/smtp/email", body);
+        },
+    });
+    // ── Sender ──────────────────────────────────────────
+    rl.registerAction("sender.create", {
+        description: "Create a sender",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Sender name" },
+            email: { type: "string", required: true, description: "Sender email" },
+        },
+        async execute(input, ctx) {
+            const { name, email } = input;
+            return apiRequest(getKey(ctx), "POST", "/v3/senders", { name, email });
+        },
+    });
+    rl.registerAction("sender.delete", {
+        description: "Delete a sender",
+        inputSchema: {
+            id: { type: "string", required: true, description: "Sender ID" },
+        },
+        async execute(input, ctx) {
+            const { id } = input;
+            await apiRequest(getKey(ctx), "DELETE", `/v3/senders/${id}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("sender.list", {
+        description: "List all senders",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await apiRequest(getKey(ctx), "GET", "/v3/senders"));
+            const senders = data.senders ?? [];
+            if (limit)
+                return senders.slice(0, limit);
+            return senders;
+        },
+    });
+}

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

@@ -0,0 +1,181 @@
+function buildBaseUrl(cfg) {
+    const hosting = cfg.hosting;
+    const appName = cfg.appName;
+    const domain = cfg.domain?.replace(/\/$/, "");
+    const environment = cfg.environment;
+    const rootUrl = hosting === "selfHosted" && domain ? domain : `https://${appName}.bubbleapps.io`;
+    const urlSegment = environment === "development" ? "/version-test/api/1.1" : "/api/1.1";
+    return `${rootUrl}${urlSegment}`;
+}
+async function apiRequest(baseUrl, token, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Bubble API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    return {
+        baseUrl: buildBaseUrl(cfg),
+        token: cfg.apiToken,
+    };
+}
+function normalizeTypeName(name) {
+    return name.replace(/\s/g, "").toLowerCase();
+}
+export default function bubble(rl) {
+    rl.setName("bubble");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: {
+            type: "string",
+            required: true,
+            description: "Bubble API token",
+            env: "BUBBLE_API_TOKEN",
+        },
+        appName: {
+            type: "string",
+            required: true,
+            description: "Bubble app name (used for hosted URL)",
+            env: "BUBBLE_APP_NAME",
+        },
+        hosting: {
+            type: "string",
+            required: false,
+            description: "bubbleHosted (default) or selfHosted",
+            env: "BUBBLE_HOSTING",
+            default: "bubbleHosted",
+        },
+        domain: {
+            type: "string",
+            required: false,
+            description: "Self-hosted domain URL (only if hosting=selfHosted)",
+            env: "BUBBLE_DOMAIN",
+        },
+        environment: {
+            type: "string",
+            required: false,
+            description: "live (default) or development",
+            env: "BUBBLE_ENVIRONMENT",
+            default: "live",
+        },
+    });
+    rl.registerAction("object.create", {
+        description: "Create an object",
+        inputSchema: {
+            typeName: { type: "string", required: true, description: "Data type name" },
+            properties: { type: "object", required: true, description: "Key-value pairs of field values" },
+        },
+        async execute(input, ctx) {
+            const { typeName, properties } = input;
+            const { baseUrl, token } = getConn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/obj/${normalizeTypeName(typeName)}`, properties);
+        },
+    });
+    rl.registerAction("object.get", {
+        description: "Get an object by ID",
+        inputSchema: {
+            typeName: { type: "string", required: true, description: "Data type name" },
+            objectId: { type: "string", required: true, description: "Object unique ID" },
+        },
+        async execute(input, ctx) {
+            const { typeName, objectId } = input;
+            const { baseUrl, token } = getConn(ctx);
+            const data = (await apiRequest(baseUrl, token, "GET", `/obj/${normalizeTypeName(typeName)}/${objectId}`));
+            return data.response;
+        },
+    });
+    rl.registerAction("object.list", {
+        description: "List objects of a type with optional constraints and sorting",
+        inputSchema: {
+            typeName: { type: "string", required: true, description: "Data type name" },
+            constraints: { type: "array", required: false, description: "Array of constraint objects [{key, constraint_type, value}]" },
+            sortField: { type: "string", required: false, description: "Field to sort by" },
+            descending: { type: "boolean", required: false, description: "Sort descending" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { typeName, constraints, sortField, descending, limit } = (input ?? {});
+            const { baseUrl, token } = getConn(ctx);
+            const qs = {};
+            if (constraints)
+                qs.constraints = JSON.stringify(constraints);
+            if (sortField) {
+                qs.sort_field = sortField;
+                if (descending)
+                    qs.descending = "true";
+            }
+            const endpoint = `/obj/${normalizeTypeName(typeName)}`;
+            if (limit) {
+                qs.limit = limit;
+                const data = (await apiRequest(baseUrl, token, "GET", endpoint, undefined, qs));
+                return data.response?.results ?? [];
+            }
+            // Paginate all
+            const results = [];
+            qs.limit = 100;
+            qs.cursor = 0;
+            while (true) {
+                const data = (await apiRequest(baseUrl, token, "GET", endpoint, undefined, qs));
+                const resp = data.response;
+                const items = resp.results ?? [];
+                results.push(...items);
+                if (resp.remaining === 0)
+                    break;
+                qs.cursor = qs.cursor + qs.limit;
+            }
+            return results;
+        },
+    });
+    rl.registerAction("object.update", {
+        description: "Update an object",
+        inputSchema: {
+            typeName: { type: "string", required: true, description: "Data type name" },
+            objectId: { type: "string", required: true, description: "Object unique ID" },
+            properties: { type: "object", required: true, description: "Key-value pairs of fields to update" },
+        },
+        async execute(input, ctx) {
+            const { typeName, objectId, properties } = input;
+            const { baseUrl, token } = getConn(ctx);
+            await apiRequest(baseUrl, token, "PATCH", `/obj/${normalizeTypeName(typeName)}/${objectId}`, properties);
+            return { success: true };
+        },
+    });
+    rl.registerAction("object.delete", {
+        description: "Delete an object",
+        inputSchema: {
+            typeName: { type: "string", required: true, description: "Data type name" },
+            objectId: { type: "string", required: true, description: "Object unique ID" },
+        },
+        async execute(input, ctx) {
+            const { typeName, objectId } = input;
+            const { baseUrl, token } = getConn(ctx);
+            await apiRequest(baseUrl, token, "DELETE", `/obj/${normalizeTypeName(typeName)}/${objectId}`);
+            return { success: true };
+        },
+    });
+}