runline 0.1.0

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

@@ -0,0 +1,252 @@
+function buildBaseUrl(subdomain) {
+    return `https://api.bamboohr.com/api/gateway.php/${subdomain}/v1`;
+}
+async function apiRequest(subdomain, apiKey, method, endpoint, body) {
+    const url = `${buildBaseUrl(subdomain)}/${endpoint}`;
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Authorization: `Basic ${btoa(`${apiKey}:x`)}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`BambooHR API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    return {
+        subdomain: ctx.connection.config.subdomain,
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+export default function bambooHr(rl) {
+    rl.setName("bambooHr");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        subdomain: {
+            type: "string",
+            required: true,
+            description: "BambooHR subdomain (e.g. 'mycompany' for mycompany.bamboohr.com)",
+            env: "BAMBOO_HR_SUBDOMAIN",
+        },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "BambooHR API key",
+            env: "BAMBOO_HR_API_KEY",
+        },
+    });
+    // ── Employee ────────────────────────────────────────
+    rl.registerAction("employee.create", {
+        description: "Create a new employee",
+        inputSchema: {
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: true, description: "Last name" },
+            department: { type: "string", required: false, description: "Department" },
+            division: { type: "string", required: false, description: "Division" },
+            employeeNumber: { type: "string", required: false, description: "Employee number" },
+            gender: { type: "string", required: false, description: "Gender (Male/Female)" },
+            hireDate: { type: "string", required: false, description: "Hire date (YYYY-MM-DD)" },
+            location: { type: "string", required: false, description: "Location" },
+            mobilePhone: { type: "string", required: false, description: "Mobile phone" },
+            preferredName: { type: "string", required: false, description: "Preferred name" },
+        },
+        async execute(input, ctx) {
+            const { subdomain, apiKey } = getConn(ctx);
+            const body = input;
+            const res = await fetch(`${buildBaseUrl(subdomain)}/employees`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    Authorization: `Basic ${btoa(`${apiKey}:x`)}`,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`BambooHR error ${res.status}: ${await res.text()}`);
+            const location = res.headers.get("location") ?? "";
+            const employeeId = location.split("/").pop();
+            return { id: employeeId };
+        },
+    });
+    rl.registerAction("employee.get", {
+        description: "Get an employee by ID",
+        inputSchema: {
+            employeeId: { type: "string", required: true, description: "Employee ID" },
+            fields: { type: "string", required: false, description: "Comma-separated field names (default: all)" },
+        },
+        async execute(input, ctx) {
+            const { employeeId, fields } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            let fieldList = fields ?? "all";
+            if (fieldList === "all") {
+                const dir = (await apiRequest(subdomain, apiKey, "GET", "employees/directory"));
+                const dirFields = dir.fields ?? [];
+                fieldList = dirFields.map((f) => f.id).join(",");
+            }
+            return apiRequest(subdomain, apiKey, "GET", `employees/${employeeId}?fields=${fieldList}`);
+        },
+    });
+    rl.registerAction("employee.list", {
+        description: "List all employees (directory)",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const { subdomain, apiKey } = getConn(ctx);
+            const data = (await apiRequest(subdomain, apiKey, "GET", "employees/directory"));
+            const employees = data.employees ?? [];
+            if (limit)
+                return employees.slice(0, limit);
+            return employees;
+        },
+    });
+    rl.registerAction("employee.update", {
+        description: "Update an employee",
+        inputSchema: {
+            employeeId: { type: "string", required: true, description: "Employee ID" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            department: { type: "string", required: false, description: "Department" },
+            division: { type: "string", required: false, description: "Division" },
+            gender: { type: "string", required: false, description: "Gender" },
+            hireDate: { type: "string", required: false, description: "Hire date (YYYY-MM-DD)" },
+            location: { type: "string", required: false, description: "Location" },
+            mobilePhone: { type: "string", required: false, description: "Mobile phone" },
+        },
+        async execute(input, ctx) {
+            const { employeeId, ...fields } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            await apiRequest(subdomain, apiKey, "POST", `employees/${employeeId}`, fields);
+            return { success: true };
+        },
+    });
+    // ── Employee Document ───────────────────────────────
+    rl.registerAction("employeeDocument.list", {
+        description: "List documents for an employee",
+        inputSchema: {
+            employeeId: { type: "string", required: true, description: "Employee ID" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { employeeId, limit } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            const data = (await apiRequest(subdomain, apiKey, "GET", `employees/${employeeId}/files/view/`));
+            const categories = data.categories ?? [];
+            // Flatten files from all categories
+            const files = [];
+            for (const cat of categories) {
+                if (cat.files)
+                    files.push(...cat.files);
+            }
+            if (limit)
+                return files.slice(0, limit);
+            return files;
+        },
+    });
+    rl.registerAction("employeeDocument.delete", {
+        description: "Delete an employee document",
+        inputSchema: {
+            employeeId: { type: "string", required: true, description: "Employee ID" },
+            fileId: { type: "string", required: true, description: "File ID" },
+        },
+        async execute(input, ctx) {
+            const { employeeId, fileId } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            await apiRequest(subdomain, apiKey, "DELETE", `employees/${employeeId}/files/${fileId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("employeeDocument.update", {
+        description: "Update an employee document's metadata",
+        inputSchema: {
+            employeeId: { type: "string", required: true, description: "Employee ID" },
+            fileId: { type: "string", required: true, description: "File ID" },
+            shareWithEmployee: { type: "boolean", required: false, description: "Share file with employee" },
+        },
+        async execute(input, ctx) {
+            const { employeeId, fileId, shareWithEmployee } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            const body = {};
+            body.shareWithEmployee = shareWithEmployee ? "yes" : "no";
+            await apiRequest(subdomain, apiKey, "POST", `employees/${employeeId}/files/${fileId}`, body);
+            return { success: true };
+        },
+    });
+    // ── Company File ────────────────────────────────────
+    rl.registerAction("file.list", {
+        description: "List company files",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const { subdomain, apiKey } = getConn(ctx);
+            const data = (await apiRequest(subdomain, apiKey, "GET", "files/view"));
+            const categories = data.categories ?? [];
+            const files = [];
+            for (const cat of categories) {
+                if (cat.files)
+                    files.push(...cat.files);
+            }
+            if (limit)
+                return files.slice(0, limit);
+            return files;
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a company file",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+        },
+        async execute(input, ctx) {
+            const { fileId } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            await apiRequest(subdomain, apiKey, "DELETE", `files/${fileId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.update", {
+        description: "Update a company file's metadata",
+        inputSchema: {
+            fileId: { type: "string", required: true, description: "File ID" },
+            shareWithEmployee: { type: "boolean", required: false, description: "Share with employees" },
+        },
+        async execute(input, ctx) {
+            const { fileId, shareWithEmployee } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            await apiRequest(subdomain, apiKey, "POST", `files/${fileId}`, {
+                shareWithEmployee: shareWithEmployee ? "yes" : "no",
+            });
+            return { success: true };
+        },
+    });
+    // ── Company Report ──────────────────────────────────
+    rl.registerAction("companyReport.get", {
+        description: "Get a company report",
+        inputSchema: {
+            reportId: { type: "string", required: true, description: "Report ID" },
+            format: { type: "string", required: false, description: "Format: JSON, CSV, XLS, XML, PDF (default: JSON)" },
+        },
+        async execute(input, ctx) {
+            const { reportId, format = "JSON" } = input;
+            const { subdomain, apiKey } = getConn(ctx);
+            return apiRequest(subdomain, apiKey, "GET", `reports/${reportId}/?format=${format}&fd=true&onlyCurrent=true`);
+        },
+    });
+}

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

@@ -0,0 +1,100 @@
+const BASE_URL = "https://api.bannerbear.com/v2";
+async function apiRequest(apiKey, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Bannerbear API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function bannerbear(rl) {
+    rl.setName("bannerbear");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Bannerbear API key",
+            env: "BANNERBEAR_API_KEY",
+        },
+    });
+    // ── Image ───────────────────────────────────────────
+    rl.registerAction("image.create", {
+        description: "Create an image from a template",
+        inputSchema: {
+            templateId: { type: "string", required: true, description: "Template UID" },
+            modifications: { type: "array", required: false, description: "Array of modification objects (name, text, color, image_url, etc.)" },
+            webhookUrl: { type: "string", required: false, description: "Webhook URL to notify on completion" },
+            metadata: { type: "string", required: false, description: "Custom metadata string" },
+            waitForImage: { type: "boolean", required: false, description: "Wait for image to finish processing (polls until complete)" },
+            maxTries: { type: "number", required: false, description: "Max poll attempts when waiting (default: 3)" },
+        },
+        async execute(input, ctx) {
+            const { templateId, modifications, webhookUrl, metadata, waitForImage, maxTries = 3 } = (input ?? {});
+            const apiKey = getKey(ctx);
+            const body = { template: templateId };
+            if (modifications)
+                body.modifications = modifications;
+            if (webhookUrl)
+                body.webhook_url = webhookUrl;
+            if (metadata)
+                body.metadata = metadata;
+            let result = (await apiRequest(apiKey, "POST", "/images", body));
+            if (waitForImage && result.status !== "completed") {
+                let tries = maxTries;
+                while (tries > 0) {
+                    await new Promise((r) => setTimeout(r, 2000));
+                    result = (await apiRequest(apiKey, "GET", `/images/${result.uid}`));
+                    if (result.status === "completed")
+                        break;
+                    tries--;
+                }
+                if (result.status !== "completed") {
+                    throw new Error("Image did not finish processing after multiple tries");
+                }
+            }
+            return result;
+        },
+    });
+    rl.registerAction("image.get", {
+        description: "Get an image by ID",
+        inputSchema: {
+            imageId: { type: "string", required: true, description: "Image UID" },
+        },
+        async execute(input, ctx) {
+            const { imageId } = input;
+            return apiRequest(getKey(ctx), "GET", `/images/${imageId}`);
+        },
+    });
+    // ── Template ────────────────────────────────────────
+    rl.registerAction("template.get", {
+        description: "Get a template by ID",
+        inputSchema: {
+            templateId: { type: "string", required: true, description: "Template UID" },
+        },
+        async execute(input, ctx) {
+            const { templateId } = input;
+            return apiRequest(getKey(ctx), "GET", `/templates/${templateId}`);
+        },
+    });
+    rl.registerAction("template.list", {
+        description: "List all templates",
+        async execute(_input, ctx) {
+            return apiRequest(getKey(ctx), "GET", "/templates");
+        },
+    });
+}

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

@@ -0,0 +1,180 @@
+async function apiRequest(host, token, method, endpoint, body, qs) {
+    const url = new URL(`${host}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Token ${token}`,
+        },
+    };
+    if (body && 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(`Baserow API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginateAll(host, token, endpoint, qs, limit) {
+    const results = [];
+    let page = 1;
+    const size = 100;
+    while (true) {
+        const data = (await apiRequest(host, token, "GET", endpoint, undefined, {
+            ...qs,
+            page,
+            size,
+        }));
+        results.push(...(data.results ?? []));
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (!data.next)
+            break;
+        page++;
+    }
+    return results;
+}
+function getConn(ctx) {
+    return {
+        host: ctx.connection.config.host.replace(/\/$/, ""),
+        token: ctx.connection.config.token,
+    };
+}
+export default function baserow(rl) {
+    rl.setName("baserow");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: {
+            type: "string",
+            required: true,
+            description: "Baserow host URL (e.g. https://api.baserow.io)",
+            env: "BASEROW_HOST",
+            default: "https://api.baserow.io",
+        },
+        token: {
+            type: "string",
+            required: true,
+            description: "Baserow database token",
+            env: "BASEROW_TOKEN",
+        },
+    });
+    // ── Row ─────────────────────────────────────────────
+    rl.registerAction("row.create", {
+        description: "Create a row in a table",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            fields: { type: "object", required: true, description: "Field values as key-value pairs (use field_N keys or field names)" },
+        },
+        async execute(input, ctx) {
+            const { tableId, fields } = input;
+            const { host, token } = getConn(ctx);
+            return apiRequest(host, token, "POST", `/api/database/rows/table/${tableId}/`, fields);
+        },
+    });
+    rl.registerAction("row.get", {
+        description: "Get a row by ID",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rowId } = input;
+            const { host, token } = getConn(ctx);
+            return apiRequest(host, token, "GET", `/api/database/rows/table/${tableId}/${rowId}/`);
+        },
+    });
+    rl.registerAction("row.list", {
+        description: "List rows from a table with optional filtering and sorting",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            search: { type: "string", required: false, description: "Search query" },
+            orderBy: { type: "string", required: false, description: "Comma-separated field IDs prefixed with +/- (e.g. +field_1,-field_2)" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { tableId, search, orderBy, limit } = input;
+            const { host, token } = getConn(ctx);
+            const qs = {};
+            if (search)
+                qs.search = search;
+            if (orderBy)
+                qs.order_by = orderBy;
+            return paginateAll(host, token, `/api/database/rows/table/${tableId}/`, qs, limit);
+        },
+    });
+    rl.registerAction("row.update", {
+        description: "Update a row (PATCH — only updates specified fields)",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+            fields: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rowId, fields } = input;
+            const { host, token } = getConn(ctx);
+            return apiRequest(host, token, "PATCH", `/api/database/rows/table/${tableId}/${rowId}/`, fields);
+        },
+    });
+    rl.registerAction("row.delete", {
+        description: "Delete a row",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rowId } = input;
+            const { host, token } = getConn(ctx);
+            await apiRequest(host, token, "DELETE", `/api/database/rows/table/${tableId}/${rowId}/`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("row.batchCreate", {
+        description: "Create up to 200 rows in one request",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            items: { type: "array", required: true, description: "Array of row objects with field values" },
+        },
+        async execute(input, ctx) {
+            const { tableId, items } = input;
+            const { host, token } = getConn(ctx);
+            return apiRequest(host, token, "POST", `/api/database/rows/table/${tableId}/batch/`, { items });
+        },
+    });
+    rl.registerAction("row.batchUpdate", {
+        description: "Update up to 200 rows in one request",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            items: { type: "array", required: true, description: "Array of { id, ...fields } objects" },
+        },
+        async execute(input, ctx) {
+            const { tableId, items } = input;
+            const { host, token } = getConn(ctx);
+            return apiRequest(host, token, "PATCH", `/api/database/rows/table/${tableId}/batch/`, { items });
+        },
+    });
+    rl.registerAction("row.batchDelete", {
+        description: "Delete up to 200 rows in one request",
+        inputSchema: {
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowIds: { type: "array", required: true, description: "Array of row IDs to delete" },
+        },
+        async execute(input, ctx) {
+            const { tableId, rowIds } = input;
+            const { host, token } = getConn(ctx);
+            await apiRequest(host, token, "POST", `/api/database/rows/table/${tableId}/batch-delete/`, {
+                items: rowIds,
+            });
+            return { success: true, deleted: rowIds };
+        },
+    });
+}