runline 0.1.0

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

@@ -0,0 +1,126 @@
+function buildBaseUrl(accountName) {
+    return `https://${accountName}.chargebee.com/api/v2`;
+}
+async function apiRequest(accountName, apiKey, method, endpoint, qs) {
+    const url = new URL(`${buildBaseUrl(accountName)}/${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: {
+            Authorization: `Basic ${btoa(`${apiKey}:`)}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    };
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Chargebee API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        accountName: ctx.connection.config.accountName,
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+export default function chargebee(rl) {
+    rl.setName("chargebee");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accountName: {
+            type: "string",
+            required: true,
+            description: "Chargebee account/site name",
+            env: "CHARGEBEE_ACCOUNT_NAME",
+        },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Chargebee API key",
+            env: "CHARGEBEE_API_KEY",
+        },
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.create", {
+        description: "Create a customer",
+        inputSchema: {
+            id: { type: "string", required: false, description: "Customer ID (auto-generated if omitted)" },
+            first_name: { type: "string", required: false, description: "First name" },
+            last_name: { type: "string", required: false, description: "Last name" },
+            email: { type: "string", required: false, description: "Email" },
+            phone: { type: "string", required: false, description: "Phone" },
+            company: { type: "string", required: false, description: "Company" },
+        },
+        async execute(input, ctx) {
+            const { accountName, apiKey } = getConn(ctx);
+            const params = (input ?? {});
+            // Chargebee uses form-encoded POST params via query string
+            return apiRequest(accountName, apiKey, "POST", "customers", params);
+        },
+    });
+    // ── Invoice ─────────────────────────────────────────
+    rl.registerAction("invoice.list", {
+        description: "List invoices",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 10, max: 100)" },
+            sortBy: { type: "string", required: false, description: "Sort field (default: date desc)" },
+        },
+        async execute(input, ctx) {
+            const { accountName, apiKey } = getConn(ctx);
+            const { limit = 10 } = (input ?? {});
+            const qs = {
+                limit,
+                "sort_by[desc]": "date",
+            };
+            const data = (await apiRequest(accountName, apiKey, "GET", "invoices", qs));
+            const list = data.list ?? [];
+            return list.map((item) => item.invoice);
+        },
+    });
+    rl.registerAction("invoice.getPdfUrl", {
+        description: "Get the PDF download URL for an invoice",
+        inputSchema: {
+            invoiceId: { type: "string", required: true, description: "Invoice ID" },
+        },
+        async execute(input, ctx) {
+            const { invoiceId } = input;
+            const { accountName, apiKey } = getConn(ctx);
+            const data = (await apiRequest(accountName, apiKey, "POST", `invoices/${invoiceId.trim()}/pdf`));
+            const download = data.download;
+            return { pdfUrl: download?.download_url };
+        },
+    });
+    // ── Subscription ────────────────────────────────────
+    rl.registerAction("subscription.cancel", {
+        description: "Cancel a subscription",
+        inputSchema: {
+            subscriptionId: { type: "string", required: true, description: "Subscription ID" },
+            endOfTerm: { type: "boolean", required: false, description: "Schedule cancellation at end of term instead of immediate" },
+        },
+        async execute(input, ctx) {
+            const { subscriptionId, endOfTerm } = input;
+            const { accountName, apiKey } = getConn(ctx);
+            const qs = {};
+            if (endOfTerm)
+                qs.end_of_term = "true";
+            return apiRequest(accountName, apiKey, "POST", `subscriptions/${subscriptionId.trim()}/cancel`, qs);
+        },
+    });
+    rl.registerAction("subscription.delete", {
+        description: "Delete a subscription",
+        inputSchema: {
+            subscriptionId: { type: "string", required: true, description: "Subscription ID" },
+        },
+        async execute(input, ctx) {
+            const { subscriptionId } = input;
+            const { accountName, apiKey } = getConn(ctx);
+            return apiRequest(accountName, apiKey, "POST", `subscriptions/${subscriptionId.trim()}/delete`);
+        },
+    });
+}

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

@@ -0,0 +1,111 @@
+const BASE_URL = "https://circleci.com/api/v2";
+async function apiRequest(token, 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: {
+            "Circle-Token": token,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`CircleCI API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+async function paginateAll(token, endpoint, qs) {
+    const results = [];
+    const q = { ...qs };
+    while (true) {
+        const data = (await apiRequest(token, "GET", endpoint, undefined, q));
+        const items = data.items ?? [];
+        results.push(...items);
+        if (!data.next_page_token)
+            break;
+        q["page-token"] = data.next_page_token;
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.apiKey;
+}
+function encodeSlug(slug) {
+    return slug.replace(/\//g, "%2F");
+}
+export default function circleci(rl) {
+    rl.setName("circleci");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "CircleCI API token",
+            env: "CIRCLECI_API_KEY",
+        },
+    });
+    rl.registerAction("pipeline.get", {
+        description: "Get a specific pipeline by number",
+        inputSchema: {
+            vcs: { type: "string", required: true, description: "VCS type: github or bitbucket" },
+            projectSlug: { type: "string", required: true, description: "Project slug (org/repo)" },
+            pipelineNumber: { type: "number", required: true, description: "Pipeline number" },
+        },
+        async execute(input, ctx) {
+            const { vcs, projectSlug, pipelineNumber } = input;
+            return apiRequest(getToken(ctx), "GET", `/project/${vcs}/${encodeSlug(projectSlug)}/pipeline/${pipelineNumber}`);
+        },
+    });
+    rl.registerAction("pipeline.list", {
+        description: "List pipelines for a project",
+        inputSchema: {
+            vcs: { type: "string", required: true, description: "VCS type: github or bitbucket" },
+            projectSlug: { type: "string", required: true, description: "Project slug (org/repo)" },
+            branch: { type: "string", required: false, description: "Filter by branch" },
+            limit: { type: "number", required: false, description: "Max results (omit for all)" },
+        },
+        async execute(input, ctx) {
+            const { vcs, projectSlug, branch, limit } = (input ?? {});
+            const token = getToken(ctx);
+            const endpoint = `/project/${vcs}/${encodeSlug(projectSlug)}/pipeline`;
+            const qs = {};
+            if (branch)
+                qs.branch = branch;
+            if (limit) {
+                qs.limit = limit;
+                const data = (await apiRequest(token, "GET", endpoint, undefined, qs));
+                return (data.items ?? []).slice(0, limit);
+            }
+            return paginateAll(token, endpoint, qs);
+        },
+    });
+    rl.registerAction("pipeline.trigger", {
+        description: "Trigger a new pipeline",
+        inputSchema: {
+            vcs: { type: "string", required: true, description: "VCS type: github or bitbucket" },
+            projectSlug: { type: "string", required: true, description: "Project slug (org/repo)" },
+            branch: { type: "string", required: false, description: "Branch to build" },
+            tag: { type: "string", required: false, description: "Tag to build" },
+        },
+        async execute(input, ctx) {
+            const { vcs, projectSlug, branch, tag } = (input ?? {});
+            const body = {};
+            if (branch)
+                body.branch = branch;
+            if (tag)
+                body.tag = tag;
+            return apiRequest(getToken(ctx), "POST", `/project/${vcs}/${encodeSlug(projectSlug)}/pipeline`, body);
+        },
+    });
+}

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

@@ -0,0 +1,245 @@
+const BASE_URL = "https://webexapis.com/v1";
+async function apiRequest(token, 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",
+            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(`Webex 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 };
+}
+async function paginateAll(token, endpoint, property, qs) {
+    const results = [];
+    const q = { ...qs, max: 100 };
+    let nextUrl;
+    while (true) {
+        const res = await fetch(nextUrl ?? `${BASE_URL}${endpoint}?${new URLSearchParams(Object.entries(q).map(([k, v]) => [k, String(v)]))}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`Webex API error ${res.status}: ${await res.text()}`);
+        const data = (await res.json());
+        results.push(...(data[property] ?? []));
+        const link = res.headers.get("link");
+        if (link?.includes('rel="next"')) {
+            const match = link.match(/<([^>]+)>/);
+            nextUrl = match?.[1];
+            if (!nextUrl)
+                break;
+        }
+        else {
+            break;
+        }
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+export default function ciscoWebex(rl) {
+    rl.setName("ciscoWebex");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Webex access token (OAuth2 or bot token)",
+            env: "WEBEX_ACCESS_TOKEN",
+        },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.create", {
+        description: "Send a message to a room or person",
+        inputSchema: {
+            roomId: { type: "string", required: false, description: "Room ID (use this or toPersonId/toPersonEmail)" },
+            toPersonId: { type: "string", required: false, description: "Person ID to message" },
+            toPersonEmail: { type: "string", required: false, description: "Person email to message" },
+            text: { type: "string", required: true, description: "Message text" },
+            markdown: { type: "string", required: false, description: "Markdown-formatted message" },
+            files: { type: "array", required: false, description: "Array of file URLs to attach" },
+        },
+        async execute(input, ctx) {
+            const body = (input ?? {});
+            return apiRequest(getToken(ctx), "POST", "/messages", body);
+        },
+    });
+    rl.registerAction("message.get", {
+        description: "Get message details",
+        inputSchema: {
+            messageId: { type: "string", required: true, description: "Message ID" },
+        },
+        async execute(input, ctx) {
+            const { messageId } = input;
+            return apiRequest(getToken(ctx), "GET", `/messages/${messageId}`);
+        },
+    });
+    rl.registerAction("message.list", {
+        description: "List messages in a room",
+        inputSchema: {
+            roomId: { type: "string", required: true, description: "Room ID" },
+            limit: { type: "number", required: false, description: "Max results (omit for all)" },
+            mentionedPeople: { type: "string", required: false, description: "Filter: 'me' or person ID" },
+            before: { type: "string", required: false, description: "List messages before this date (ISO 8601)" },
+            beforeMessage: { type: "string", required: false, description: "List messages before this message ID" },
+        },
+        async execute(input, ctx) {
+            const { roomId, limit, mentionedPeople, before, beforeMessage } = (input ?? {});
+            const qs = { roomId };
+            if (mentionedPeople)
+                qs.mentionedPeople = mentionedPeople;
+            if (before)
+                qs.before = before;
+            if (beforeMessage)
+                qs.beforeMessage = beforeMessage;
+            if (limit) {
+                qs.max = limit;
+                const data = (await apiRequest(getToken(ctx), "GET", "/messages", undefined, qs));
+                return data.items;
+            }
+            return paginateAll(getToken(ctx), "/messages", "items", qs);
+        },
+    });
+    rl.registerAction("message.update", {
+        description: "Edit a message",
+        inputSchema: {
+            messageId: { type: "string", required: true, description: "Message ID" },
+            text: { type: "string", required: false, description: "New plain text" },
+            markdown: { type: "string", required: false, description: "New markdown text" },
+        },
+        async execute(input, ctx) {
+            const { messageId, text, markdown } = input;
+            // Need roomId from original message
+            const original = (await apiRequest(getToken(ctx), "GET", `/messages/${messageId}`));
+            const body = { roomId: original.roomId };
+            if (markdown)
+                body.markdown = markdown;
+            else if (text)
+                body.text = text;
+            return apiRequest(getToken(ctx), "PUT", `/messages/${messageId}`, body);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: {
+            messageId: { type: "string", required: true, description: "Message ID" },
+        },
+        async execute(input, ctx) {
+            const { messageId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/messages/${messageId}`);
+            return { success: true };
+        },
+    });
+    // ── Meeting ─────────────────────────────────────────
+    rl.registerAction("meeting.create", {
+        description: "Create a meeting",
+        inputSchema: {
+            title: { type: "string", required: true, description: "Meeting title" },
+            start: { type: "string", required: true, description: "Start time (ISO 8601)" },
+            end: { type: "string", required: true, description: "End time (ISO 8601)" },
+            invitees: { type: "array", required: false, description: "Array of {email} objects" },
+            agenda: { type: "string", required: false, description: "Meeting agenda" },
+            password: { type: "string", required: false, description: "Meeting password" },
+            enabledAutoRecordMeeting: { type: "boolean", required: false, description: "Auto-record" },
+            allowAnyUserToBeCoHost: { type: "boolean", required: false, description: "Allow any user to be co-host" },
+        },
+        async execute(input, ctx) {
+            const body = (input ?? {});
+            return apiRequest(getToken(ctx), "POST", "/meetings", body);
+        },
+    });
+    rl.registerAction("meeting.get", {
+        description: "Get meeting details",
+        inputSchema: {
+            meetingId: { type: "string", required: true, description: "Meeting ID" },
+        },
+        async execute(input, ctx) {
+            const { meetingId } = input;
+            return apiRequest(getToken(ctx), "GET", `/meetings/${meetingId}`);
+        },
+    });
+    rl.registerAction("meeting.list", {
+        description: "List meetings",
+        inputSchema: {
+            from: { type: "string", required: false, description: "Start date filter (ISO 8601)" },
+            to: { type: "string", required: false, description: "End date filter (ISO 8601)" },
+            meetingType: { type: "string", required: false, description: "Meeting type filter" },
+            state: { type: "string", required: false, description: "State filter" },
+            limit: { type: "number", required: false, description: "Max results (omit for all)" },
+        },
+        async execute(input, ctx) {
+            const { from, to, meetingType, state, limit } = (input ?? {});
+            const qs = {};
+            if (from)
+                qs.from = from;
+            if (to)
+                qs.to = to;
+            if (meetingType)
+                qs.meetingType = meetingType;
+            if (state)
+                qs.state = state;
+            if (limit) {
+                qs.max = limit;
+                const data = (await apiRequest(getToken(ctx), "GET", "/meetings", undefined, qs));
+                return data.items;
+            }
+            return paginateAll(getToken(ctx), "/meetings", "items", qs);
+        },
+    });
+    rl.registerAction("meeting.update", {
+        description: "Update a meeting",
+        inputSchema: {
+            meetingId: { type: "string", required: true, description: "Meeting ID" },
+            title: { type: "string", required: false, description: "New title" },
+            start: { type: "string", required: false, description: "New start time (ISO 8601)" },
+            end: { type: "string", required: false, description: "New end time (ISO 8601)" },
+            password: { type: "string", required: false, description: "New password" },
+            invitees: { type: "array", required: false, description: "Array of {email} objects" },
+        },
+        async execute(input, ctx) {
+            const { meetingId, ...fields } = input;
+            // API requires title, password, start, end — fetch current if not provided
+            const current = (await apiRequest(getToken(ctx), "GET", `/meetings/${meetingId}`));
+            const body = {
+                title: fields.title ?? current.title,
+                password: fields.password ?? current.password,
+                start: fields.start ?? current.start,
+                end: fields.end ?? current.end,
+                ...fields,
+            };
+            delete body.meetingId;
+            return apiRequest(getToken(ctx), "PUT", `/meetings/${meetingId}`, body);
+        },
+    });
+    rl.registerAction("meeting.delete", {
+        description: "Delete a meeting",
+        inputSchema: {
+            meetingId: { type: "string", required: true, description: "Meeting ID" },
+        },
+        async execute(input, ctx) {
+            const { meetingId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/meetings/${meetingId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,103 @@
+async function apiRequest(apiKey, subdomain, endpoint, qs) {
+    const url = new URL(`https://${subdomain}.clearbit.com${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Clearbit API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function clearbit(rl) {
+    rl.setName("clearbit");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Clearbit API key",
+            env: "CLEARBIT_API_KEY",
+        },
+    });
+    rl.registerAction("person.enrich", {
+        description: "Look up a person by email address",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address" },
+            givenName: { type: "string", required: false, description: "First name hint" },
+            familyName: { type: "string", required: false, description: "Last name hint" },
+            ipAddress: { type: "string", required: false, description: "IP address hint" },
+            location: { type: "string", required: false, description: "Location hint" },
+            company: { type: "string", required: false, description: "Company name hint" },
+            companyDomain: { type: "string", required: false, description: "Company domain hint" },
+            linkedin: { type: "string", required: false, description: "LinkedIn URL hint" },
+            twitter: { type: "string", required: false, description: "Twitter handle hint" },
+            facebook: { type: "string", required: false, description: "Facebook URL hint" },
+        },
+        async execute(input, ctx) {
+            const { email, givenName, familyName, ipAddress, location, company, companyDomain, linkedin, twitter, facebook } = (input ?? {});
+            const qs = { email };
+            if (givenName)
+                qs.given_name = givenName;
+            if (familyName)
+                qs.family_name = familyName;
+            if (ipAddress)
+                qs.ip_address = ipAddress;
+            if (location)
+                qs.location = location;
+            if (company)
+                qs.company = company;
+            if (companyDomain)
+                qs.company_domain = companyDomain;
+            if (linkedin)
+                qs.linkedin = linkedin;
+            if (twitter)
+                qs.twitter = twitter;
+            if (facebook)
+                qs.facebook = facebook;
+            return apiRequest(getKey(ctx), "person-stream", "/v2/people/find", qs);
+        },
+    });
+    rl.registerAction("company.enrich", {
+        description: "Look up a company by domain",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Company domain" },
+            companyName: { type: "string", required: false, description: "Company name hint" },
+            linkedin: { type: "string", required: false, description: "LinkedIn URL hint" },
+            twitter: { type: "string", required: false, description: "Twitter handle hint" },
+            facebook: { type: "string", required: false, description: "Facebook URL hint" },
+        },
+        async execute(input, ctx) {
+            const { domain, companyName, linkedin, twitter, facebook } = (input ?? {});
+            const qs = { domain };
+            if (companyName)
+                qs.company_name = companyName;
+            if (linkedin)
+                qs.linkedin = linkedin;
+            if (twitter)
+                qs.twitter = twitter;
+            if (facebook)
+                qs.facebook = facebook;
+            return apiRequest(getKey(ctx), "company-stream", "/v2/companies/find", qs);
+        },
+    });
+    rl.registerAction("company.autocomplete", {
+        description: "Autocomplete company names",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Partial company name" },
+        },
+        async execute(input, ctx) {
+            const { name } = input;
+            return apiRequest(getKey(ctx), "autocomplete", "/v1/companies/suggest", { query: name });
+        },
+    });
+}