runline 0.1.0

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

@@ -0,0 +1,31 @@
+export default function lingvanex(rl) {
+    rl.setName("lingvanex");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Lingvanex API key", env: "LINGVANEX_API_KEY" } });
+    rl.registerAction("translate", {
+        description: "Translate text",
+        inputSchema: {
+            text: { type: "string", required: true, description: "Text to translate" },
+            to: { type: "string", required: true, description: "Target language code (e.g. en_GB, fr_FR)" },
+            from: { type: "string", required: false, description: "Source language code (auto-detect if omitted)" },
+            platform: { type: "string", required: false, description: "api (default)" },
+            translateMode: { type: "string", required: false, description: "'html' to translate preserving HTML structure, or omit for plain text" },
+        },
+        async execute(input, ctx) {
+            const { text, to, from: src, platform = "api", translateMode } = input;
+            const body = { data: text, to, platform };
+            if (src)
+                body.from = src;
+            if (translateMode)
+                body.translateMode = translateMode;
+            const res = await fetch("https://api-b2b.backenster.com/b1/api/v3/translate", {
+                method: "POST",
+                headers: { Authorization: `Bearer ${ctx.connection.config.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`Lingvanex error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

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

@@ -0,0 +1,80 @@
+const BASE_URL = "https://api.linkedin.com";
+async function apiRequest(token, method, endpoint, body) {
+    const isAbsolute = endpoint.startsWith("http");
+    const url = isAbsolute ? endpoint : `${BASE_URL}/rest${endpoint}`;
+    const opts = {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "X-Restli-Protocol-Version": "2.0.0",
+            "LinkedIn-Version": "202504",
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(url, opts);
+    if (res.status === 201) {
+        return { urn: res.headers.get("x-restli-id") };
+    }
+    if (!res.ok)
+        throw new Error(`LinkedIn API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+// LinkedIn "little text" format escaping
+function escapeText(text) {
+    return text.replace(/[(*)\[\]{}<>@|~_]/g, (char) => "\\" + char);
+}
+export default function linkedin(rl) {
+    rl.setName("linkedin");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "LinkedIn OAuth2 access token", env: "LINKEDIN_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("post.create", {
+        description: "Create a post on LinkedIn. Supports text-only, article shares, and text with commentary. Image uploads require binary data and are not supported in this plugin.",
+        inputSchema: {
+            postAs: { type: "string", required: true, description: "'person' or 'organization'" },
+            personOrOrgId: { type: "string", required: true, description: "Person ID or Organization ID (without URN prefix)" },
+            text: { type: "string", required: true, description: "Post text/commentary" },
+            shareMediaCategory: { type: "string", required: false, description: "'NONE' (default, text only), 'ARTICLE' (link share)" },
+            visibility: { type: "string", required: false, description: "PUBLIC (default) or CONNECTIONS. Only applies when posting as person." },
+            articleUrl: { type: "string", required: false, description: "URL for article share (required when shareMediaCategory is ARTICLE)" },
+            articleTitle: { type: "string", required: false },
+            articleDescription: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { postAs, personOrOrgId, text, shareMediaCategory = "NONE", visibility = "PUBLIC", articleUrl, articleTitle, articleDescription, } = input;
+            const authorUrn = postAs === "person"
+                ? `urn:li:person:${personOrOrgId}`
+                : `urn:li:organization:${personOrOrgId}`;
+            const escapedText = escapeText(text);
+            const body = {
+                author: authorUrn,
+                lifecycleState: "PUBLISHED",
+                distribution: {
+                    feedDistribution: "MAIN_FEED",
+                    thirdPartyDistributionChannels: [],
+                },
+                visibility: postAs === "person" ? visibility : "PUBLIC",
+            };
+            if (shareMediaCategory === "ARTICLE" && articleUrl) {
+                const article = { source: articleUrl };
+                if (articleTitle)
+                    article.title = articleTitle;
+                if (articleDescription)
+                    article.description = articleDescription;
+                body.content = { article };
+                body.commentary = escapedText;
+            }
+            else {
+                body.commentary = escapedText;
+            }
+            return apiRequest(tok(ctx), "POST", "/posts", body);
+        },
+    });
+}

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

@@ -0,0 +1,119 @@
+const BASE_URL = "https://public-api.lonescale.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: { "X-API-KEY": apiKey, "Content-Type": "application/json" },
+    };
+    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)
+        throw new Error(`LoneScale API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function lonescale(rl) {
+    rl.setName("lonescale");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "LoneScale API key", env: "LONESCALE_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("list.create", {
+        description: "Create a new list",
+        inputSchema: {
+            name: { type: "string", required: true, description: "List name" },
+            entity: { type: "string", required: true, description: "PEOPLE or COMPANY" },
+        },
+        async execute(input, ctx) {
+            const { name, entity } = input;
+            return apiRequest(key(ctx), "POST", "/lists", { name, entity });
+        },
+    });
+    rl.registerAction("list.list", {
+        description: "List all lists, optionally filtered by entity type",
+        inputSchema: {
+            entity: { type: "string", required: false, description: "PEOPLE or COMPANY" },
+        },
+        async execute(input, ctx) {
+            const { entity } = (input ?? {});
+            const qs = {};
+            if (entity)
+                qs.entity = entity;
+            return apiRequest(key(ctx), "GET", "/lists", undefined, qs);
+        },
+    });
+    rl.registerAction("item.addPerson", {
+        description: "Add a person (contact) to a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            firstName: { type: "string", required: true },
+            lastName: { type: "string", required: true },
+            fullName: { type: "string", required: false },
+            email: { type: "string", required: false },
+            companyName: { type: "string", required: false },
+            currentPosition: { type: "string", required: false },
+            domain: { type: "string", required: false, description: "Company domain" },
+            linkedinUrl: { type: "string", required: false },
+            location: { type: "string", required: false },
+            contactId: { type: "string", required: false, description: "Contact ID from your source" },
+        },
+        async execute(input, ctx) {
+            const { listId, firstName, lastName, fullName, email, companyName, currentPosition, domain, linkedinUrl, location, contactId } = input;
+            const body = {};
+            if (firstName)
+                body.first_name = firstName;
+            if (lastName)
+                body.last_name = lastName;
+            if (fullName)
+                body.full_name = fullName;
+            if (email)
+                body.email = email;
+            if (companyName)
+                body.company_name = companyName;
+            if (currentPosition)
+                body.current_position = currentPosition;
+            if (domain)
+                body.domain = domain;
+            if (linkedinUrl)
+                body.linkedin_url = linkedinUrl;
+            if (location)
+                body.location = location;
+            if (contactId)
+                body.contact_id = contactId;
+            return apiRequest(key(ctx), "POST", `/lists/${listId}/item`, body);
+        },
+    });
+    rl.registerAction("item.addCompany", {
+        description: "Add a company to a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            companyName: { type: "string", required: true },
+            linkedinUrl: { type: "string", required: false },
+            domain: { type: "string", required: false, description: "Company domain" },
+            location: { type: "string", required: false },
+            contactId: { type: "string", required: false, description: "Contact ID from your source" },
+        },
+        async execute(input, ctx) {
+            const { listId, companyName, linkedinUrl, domain, location, contactId } = input;
+            const body = {};
+            if (companyName)
+                body.company_name = companyName;
+            if (linkedinUrl)
+                body.linkedin_url = linkedinUrl;
+            if (domain)
+                body.domain = domain;
+            if (location)
+                body.location = location;
+            if (contactId)
+                body.contact_id = contactId;
+            return apiRequest(key(ctx), "POST", `/lists/${listId}/item`, body);
+        },
+    });
+}

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

@@ -0,0 +1,300 @@
+async function apiRequest(host, token, method, endpoint, body, qs) {
+    const url = new URL(`${host}${endpoint}`);
+    if (qs) {
+        // Magento uses nested query params like search_criteria[page_size]=10
+        function flatten(obj, prefix = "") {
+            if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+                for (const [k, v] of Object.entries(obj)) {
+                    flatten(v, prefix ? `${prefix}[${k}]` : k);
+                }
+            }
+            else if (Array.isArray(obj)) {
+                for (let i = 0; i < obj.length; i++) {
+                    flatten(obj[i], `${prefix}[${i}]`);
+                }
+            }
+            else if (obj !== undefined && obj !== null) {
+                url.searchParams.set(prefix, String(obj));
+            }
+        }
+        flatten(qs);
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    };
+    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)
+        throw new Error(`Magento API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function searchAll(host, token, endpoint, searchCriteria = {}) {
+    const all = [];
+    searchCriteria.page_size = 100;
+    let currentPage = 1;
+    let totalCount = Infinity;
+    while (all.length < totalCount) {
+        searchCriteria.current_page = currentPage;
+        const data = (await apiRequest(host, token, "GET", endpoint, undefined, { search_criteria: searchCriteria }));
+        totalCount = data.total_count ?? 0;
+        const items = data.items;
+        if (items)
+            all.push(...items);
+        else
+            break;
+        currentPage++;
+    }
+    return all;
+}
+export default function magento(rl) {
+    rl.setName("magento");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "Magento store URL (e.g. https://mystore.com)", env: "MAGENTO_HOST" },
+        accessToken: { type: "string", required: true, description: "Integration access token", env: "MAGENTO_ACCESS_TOKEN" },
+    });
+    const conn = (ctx) => ({
+        host: ctx.connection.config.host.replace(/\/$/, ""),
+        token: ctx.connection.config.accessToken,
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.create", {
+        description: "Create a customer",
+        inputSchema: {
+            email: { type: "string", required: true },
+            firstname: { type: "string", required: true },
+            lastname: { type: "string", required: true },
+            password: { type: "string", required: false },
+            addresses: { type: "array", required: false, description: "Array of address objects (street as string, city, postcode, country_id, firstname, lastname, telephone required)" },
+            customAttributes: { type: "array", required: false, description: "Array of {attribute_code, value} objects" },
+            additionalFields: { type: "object", required: false, description: "middlename, prefix, suffix, dob, gender (1=male,2=female,3=unspecified), group_id, store_id, website_id, etc." },
+        },
+        async execute(input, ctx) {
+            const { email, firstname, lastname, password, addresses, customAttributes, additionalFields } = input;
+            const { host, token } = conn(ctx);
+            const customer = { email, firstname, lastname };
+            if (addresses && Array.isArray(addresses)) {
+                customer.addresses = addresses.map((a) => ({
+                    ...a,
+                    street: Array.isArray(a.street) ? a.street : [a.street],
+                }));
+            }
+            if (customAttributes)
+                customer.custom_attributes = customAttributes;
+            if (additionalFields)
+                Object.assign(customer, additionalFields);
+            const body = { customer };
+            if (password)
+                body.password = password;
+            return apiRequest(host, token, "POST", "/rest/V1/customers", body);
+        },
+    });
+    rl.registerAction("customer.get", {
+        description: "Get a customer by ID",
+        inputSchema: { customerId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            return apiRequest(host, token, "GET", `/rest/default/V1/customers/${input.customerId}`);
+        },
+    });
+    rl.registerAction("customer.list", {
+        description: "Search/list customers using Magento search_criteria",
+        inputSchema: {
+            searchCriteria: { type: "object", required: false, description: "Magento search_criteria object (filter_groups, sort_orders, page_size). Omit for all." },
+            limit: { type: "number", required: false, description: "Max results (if not using searchCriteria)" },
+        },
+        async execute(input, ctx) {
+            const { searchCriteria, limit } = (input ?? {});
+            const { host, token } = conn(ctx);
+            if (searchCriteria) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/customers/search", undefined, { search_criteria: searchCriteria });
+                return data.items;
+            }
+            if (limit) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/customers/search", undefined, { search_criteria: { page_size: limit } });
+                return data.items;
+            }
+            return searchAll(host, token, "/rest/default/V1/customers/search");
+        },
+    });
+    rl.registerAction("customer.update", {
+        description: "Update a customer",
+        inputSchema: {
+            customerId: { type: "number", required: true },
+            email: { type: "string", required: true },
+            firstname: { type: "string", required: true },
+            lastname: { type: "string", required: true },
+            updateFields: { type: "object", required: false, description: "Fields to update (middlename, dob, gender, group_id, etc.)" },
+            addresses: { type: "array", required: false },
+            customAttributes: { type: "array", required: false },
+        },
+        async execute(input, ctx) {
+            const { customerId, email, firstname, lastname, updateFields, addresses, customAttributes } = input;
+            const { host, token } = conn(ctx);
+            const customer = { email, firstname, lastname, id: customerId, website_id: 0 };
+            if (addresses && Array.isArray(addresses)) {
+                customer.addresses = addresses.map((a) => ({
+                    ...a,
+                    street: Array.isArray(a.street) ? a.street : [a.street],
+                }));
+            }
+            if (customAttributes)
+                customer.custom_attributes = customAttributes;
+            if (updateFields)
+                Object.assign(customer, updateFields);
+            return apiRequest(host, token, "PUT", `/rest/V1/customers/${customerId}`, { customer });
+        },
+    });
+    rl.registerAction("customer.delete", {
+        description: "Delete a customer",
+        inputSchema: { customerId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            await apiRequest(host, token, "DELETE", `/rest/default/V1/customers/${input.customerId}`);
+            return { success: true };
+        },
+    });
+    // ── Invoice ─────────────────────────────────────────
+    rl.registerAction("invoice.create", {
+        description: "Create an invoice for an order",
+        inputSchema: { orderId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            await apiRequest(host, token, "POST", `/rest/default/V1/order/${input.orderId}/invoice`);
+            return { success: true };
+        },
+    });
+    // ── Order ───────────────────────────────────────────
+    rl.registerAction("order.get", {
+        description: "Get an order by ID",
+        inputSchema: { orderId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            return apiRequest(host, token, "GET", `/rest/default/V1/orders/${input.orderId}`);
+        },
+    });
+    rl.registerAction("order.list", {
+        description: "Search/list orders",
+        inputSchema: {
+            searchCriteria: { type: "object", required: false, description: "Magento search_criteria object" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { searchCriteria, limit } = (input ?? {});
+            const { host, token } = conn(ctx);
+            if (searchCriteria) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/orders", undefined, { search_criteria: searchCriteria });
+                return data.items;
+            }
+            if (limit) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/orders", undefined, { search_criteria: { page_size: limit } });
+                return data.items;
+            }
+            return searchAll(host, token, "/rest/default/V1/orders");
+        },
+    });
+    rl.registerAction("order.cancel", {
+        description: "Cancel an order",
+        inputSchema: { orderId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            await apiRequest(host, token, "POST", `/rest/default/V1/orders/${input.orderId}/cancel`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("order.ship", {
+        description: "Ship an order",
+        inputSchema: { orderId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            await apiRequest(host, token, "POST", `/rest/default/V1/order/${input.orderId}/ship`);
+            return { success: true };
+        },
+    });
+    // ── Product ─────────────────────────────────────────
+    rl.registerAction("product.create", {
+        description: "Create a product",
+        inputSchema: {
+            sku: { type: "string", required: true },
+            name: { type: "string", required: true },
+            attributeSetId: { type: "number", required: true },
+            price: { type: "number", required: true },
+            additionalFields: { type: "object", required: false, description: "status (1=enabled,2=disabled), visibility (1-4), weight, type_id, etc." },
+            customAttributes: { type: "array", required: false, description: "Array of {attribute_code, value}" },
+        },
+        async execute(input, ctx) {
+            const { sku, name, attributeSetId, price, additionalFields, customAttributes } = input;
+            const { host, token } = conn(ctx);
+            const product = { sku, name, attribute_set_id: attributeSetId, price };
+            if (customAttributes)
+                product.custom_attributes = customAttributes;
+            if (additionalFields)
+                Object.assign(product, additionalFields);
+            return apiRequest(host, token, "POST", "/rest/default/V1/products", { product });
+        },
+    });
+    rl.registerAction("product.get", {
+        description: "Get a product by SKU",
+        inputSchema: { sku: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            return apiRequest(host, token, "GET", `/rest/default/V1/products/${encodeURIComponent(input.sku)}`);
+        },
+    });
+    rl.registerAction("product.list", {
+        description: "Search/list products",
+        inputSchema: {
+            searchCriteria: { type: "object", required: false },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { searchCriteria, limit } = (input ?? {});
+            const { host, token } = conn(ctx);
+            if (searchCriteria) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/products", undefined, { search_criteria: searchCriteria });
+                return data.items;
+            }
+            if (limit) {
+                const data = await apiRequest(host, token, "GET", "/rest/default/V1/products", undefined, { search_criteria: { page_size: limit } });
+                return data.items;
+            }
+            return searchAll(host, token, "/rest/default/V1/products");
+        },
+    });
+    rl.registerAction("product.update", {
+        description: "Update a product by SKU",
+        inputSchema: {
+            sku: { type: "string", required: true },
+            updateFields: { type: "object", required: true, description: "Fields to update (name, price, status, visibility, weight, attribute_set_id, etc.)" },
+            customAttributes: { type: "array", required: false },
+        },
+        async execute(input, ctx) {
+            const { sku, updateFields, customAttributes } = input;
+            const { host, token } = conn(ctx);
+            const product = { sku };
+            if (customAttributes)
+                product.custom_attributes = customAttributes;
+            Object.assign(product, updateFields);
+            return apiRequest(host, token, "PUT", `/rest/default/V1/products/${encodeURIComponent(sku)}`, { product });
+        },
+    });
+    rl.registerAction("product.delete", {
+        description: "Delete a product by SKU",
+        inputSchema: { sku: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { host, token } = conn(ctx);
+            await apiRequest(host, token, "DELETE", `/rest/default/V1/products/${encodeURIComponent(input.sku)}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,27 @@
+export default function mailcheck(rl) {
+    rl.setName("mailcheck");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Mailcheck API key", env: "MAILCHECK_API_KEY" },
+    });
+    rl.registerAction("email.check", {
+        description: "Verify an email address",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address to check" },
+        },
+        async execute(input, ctx) {
+            const { email } = input;
+            const res = await fetch("https://api.mailcheck.co/v1/singleEmail:check", {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${ctx.connection.config.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ email }),
+            });
+            if (!res.ok)
+                throw new Error(`Mailcheck API error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}