runline 0.1.0

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

@@ -0,0 +1,146 @@
+async function apiRequest(host, token, endpoint, qs) {
+    const url = new URL(`https://${host}${endpoint}`);
+    url.searchParams.set("access_token", token);
+    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: { Accept: "application/json" } });
+    if (!res.ok)
+        throw new Error(`Contentful API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginateAll(host, token, endpoint, qs, limit) {
+    const results = [];
+    let skip = 0;
+    const size = 100;
+    while (true) {
+        const data = (await apiRequest(host, token, endpoint, { ...qs, skip, limit: size }));
+        const items = data.items ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (items.length < size)
+            break;
+        skip += size;
+    }
+    return results;
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    const isPreview = cfg.source === "preview";
+    return {
+        host: isPreview ? "preview.contentful.com" : "cdn.contentful.com",
+        token: (isPreview ? cfg.previewAccessToken : cfg.deliveryAccessToken),
+        spaceId: cfg.spaceId,
+    };
+}
+export default function contentful(rl) {
+    rl.setName("contentful");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        spaceId: { type: "string", required: true, description: "Contentful Space ID", env: "CONTENTFUL_SPACE_ID" },
+        deliveryAccessToken: { type: "string", required: true, description: "Content Delivery API access token", env: "CONTENTFUL_DELIVERY_TOKEN" },
+        previewAccessToken: { type: "string", required: false, description: "Content Preview API access token", env: "CONTENTFUL_PREVIEW_TOKEN" },
+        source: { type: "string", required: false, description: "'delivery' (default) or 'preview'", default: "delivery" },
+    });
+    // ── Space ───────────────────────────────────────────
+    rl.registerAction("space.get", {
+        description: "Get space details",
+        async execute(_input, ctx) {
+            const { host, token, spaceId } = getConn(ctx);
+            return apiRequest(host, token, `/spaces/${spaceId}`);
+        },
+    });
+    // ── Content Type ────────────────────────────────────
+    rl.registerAction("contentType.get", {
+        description: "Get a content type",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID (e.g. master)" },
+            contentTypeId: { type: "string", required: true, description: "Content type ID" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, contentTypeId } = input;
+            const { host, token, spaceId } = getConn(ctx);
+            return apiRequest(host, token, `/spaces/${spaceId}/environments/${environmentId}/content_types/${contentTypeId}`);
+        },
+    });
+    // ── Entry ───────────────────────────────────────────
+    rl.registerAction("entry.get", {
+        description: "Get an entry by ID",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID" },
+            entryId: { type: "string", required: true, description: "Entry ID" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, entryId } = input;
+            const { host, token, spaceId } = getConn(ctx);
+            return apiRequest(host, token, `/spaces/${spaceId}/environments/${environmentId}/entries/${entryId}`);
+        },
+    });
+    rl.registerAction("entry.list", {
+        description: "List entries",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID" },
+            contentType: { type: "string", required: false, description: "Filter by content type ID" },
+            query: { type: "string", required: false, description: "Full-text search query" },
+            select: { type: "string", required: false, description: "Comma-separated fields to select" },
+            order: { type: "string", required: false, description: "Order by field" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, contentType, query, select, order, limit } = (input ?? {});
+            const { host, token, spaceId } = getConn(ctx);
+            const qs = {};
+            if (contentType)
+                qs.content_type = contentType;
+            if (query)
+                qs.query = query;
+            if (select)
+                qs.select = select;
+            if (order)
+                qs.order = order;
+            return paginateAll(host, token, `/spaces/${spaceId}/environments/${environmentId}/entries`, qs, limit);
+        },
+    });
+    // ── Asset ───────────────────────────────────────────
+    rl.registerAction("asset.get", {
+        description: "Get an asset by ID",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID" },
+            assetId: { type: "string", required: true, description: "Asset ID" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, assetId } = input;
+            const { host, token, spaceId } = getConn(ctx);
+            return apiRequest(host, token, `/spaces/${spaceId}/environments/${environmentId}/assets/${assetId}`);
+        },
+    });
+    rl.registerAction("asset.list", {
+        description: "List assets",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, limit } = (input ?? {});
+            const { host, token, spaceId } = getConn(ctx);
+            return paginateAll(host, token, `/spaces/${spaceId}/environments/${environmentId}/assets`, undefined, limit);
+        },
+    });
+    // ── Locale ──────────────────────────────────────────
+    rl.registerAction("locale.list", {
+        description: "List locales",
+        inputSchema: {
+            environmentId: { type: "string", required: true, description: "Environment ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { environmentId, limit } = (input ?? {});
+            const { host, token, spaceId } = getConn(ctx);
+            return paginateAll(host, token, `/spaces/${spaceId}/environments/${environmentId}/locales`, undefined, limit);
+        },
+    });
+}

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

@@ -0,0 +1,270 @@
+const BASE_URL = "https://api.convertkit.com/v3";
+async function apiRequest(apiSecret, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    // GET requests use api_secret as query param
+    if (method === "GET" || method === "DELETE") {
+        url.searchParams.set("api_secret", apiSecret);
+    }
+    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" },
+    };
+    if (method === "POST" || method === "PUT") {
+        const b = { api_secret: apiSecret, ...body };
+        opts.body = JSON.stringify(b);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`ConvertKit API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getSecret(ctx) {
+    return ctx.connection.config.apiSecret;
+}
+export default function convertkit(rl) {
+    rl.setName("convertkit");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiSecret: {
+            type: "string",
+            required: true,
+            description: "ConvertKit API secret",
+            env: "CONVERTKIT_API_SECRET",
+        },
+    });
+    // ── Custom Field ────────────────────────────────────
+    rl.registerAction("customField.create", {
+        description: "Create a custom field",
+        inputSchema: {
+            label: { type: "string", required: true, description: "Field label" },
+        },
+        async execute(input, ctx) {
+            const { label } = input;
+            return apiRequest(getSecret(ctx), "POST", "/custom_fields", { label });
+        },
+    });
+    rl.registerAction("customField.get", {
+        description: "Get a custom field",
+        inputSchema: { id: { type: "string", required: true, description: "Field ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getSecret(ctx), "GET", `/custom_fields/${input.id}`);
+        },
+    });
+    rl.registerAction("customField.list", {
+        description: "List custom fields",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(getSecret(ctx), "GET", "/custom_fields"));
+            const fields = data.custom_fields ?? [];
+            const { limit } = (input ?? {});
+            if (limit)
+                return fields.slice(0, limit);
+            return fields;
+        },
+    });
+    rl.registerAction("customField.update", {
+        description: "Update a custom field label",
+        inputSchema: {
+            id: { type: "string", required: true, description: "Field ID" },
+            label: { type: "string", required: true, description: "New label" },
+        },
+        async execute(input, ctx) {
+            const { id, label } = input;
+            await apiRequest(getSecret(ctx), "PUT", `/custom_fields/${id}`, { label });
+            return { success: true };
+        },
+    });
+    rl.registerAction("customField.delete", {
+        description: "Delete a custom field",
+        inputSchema: { id: { type: "string", required: true, description: "Field ID" } },
+        async execute(input, ctx) {
+            return apiRequest(getSecret(ctx), "DELETE", `/custom_fields/${input.id}`);
+        },
+    });
+    // ── Form ────────────────────────────────────────────
+    rl.registerAction("form.addSubscriber", {
+        description: "Add a subscriber to a form",
+        inputSchema: {
+            formId: { type: "string", required: true, description: "Form ID" },
+            email: { type: "string", required: true, description: "Subscriber email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            tags: { type: "array", required: false, description: "Tag IDs to add" },
+            fields: { type: "object", required: false, description: "Custom field key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { formId, email, firstName, tags, fields } = input;
+            const body = { email };
+            if (firstName)
+                body.first_name = firstName;
+            if (tags)
+                body.tags = tags;
+            if (fields)
+                body.fields = fields;
+            const data = (await apiRequest(getSecret(ctx), "POST", `/forms/${formId}/subscribe`, body));
+            return data.subscription;
+        },
+    });
+    rl.registerAction("form.list", {
+        description: "List forms",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(getSecret(ctx), "GET", "/forms"));
+            const forms = data.forms ?? [];
+            const { limit } = (input ?? {});
+            if (limit)
+                return forms.slice(0, limit);
+            return forms;
+        },
+    });
+    rl.registerAction("form.getSubscriptions", {
+        description: "List subscriptions for a form",
+        inputSchema: {
+            formId: { type: "string", required: true, description: "Form ID" },
+            subscriberState: { type: "string", required: false, description: "Filter: active, cancelled" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { formId, subscriberState, limit } = (input ?? {});
+            const qs = {};
+            if (subscriberState)
+                qs.subscriber_state = subscriberState;
+            const data = (await apiRequest(getSecret(ctx), "GET", `/forms/${formId}/subscriptions`, undefined, qs));
+            const subs = data.subscriptions ?? [];
+            if (limit)
+                return subs.slice(0, limit);
+            return subs;
+        },
+    });
+    // ── Sequence ────────────────────────────────────────
+    rl.registerAction("sequence.addSubscriber", {
+        description: "Add a subscriber to a sequence",
+        inputSchema: {
+            sequenceId: { type: "string", required: true, description: "Sequence ID" },
+            email: { type: "string", required: true, description: "Subscriber email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            tags: { type: "array", required: false, description: "Tag IDs" },
+            fields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { sequenceId, email, firstName, tags, fields } = input;
+            const body = { email };
+            if (firstName)
+                body.first_name = firstName;
+            if (tags)
+                body.tags = tags;
+            if (fields)
+                body.fields = fields;
+            const data = (await apiRequest(getSecret(ctx), "POST", `/sequences/${sequenceId}/subscribe`, body));
+            return data.subscription;
+        },
+    });
+    rl.registerAction("sequence.list", {
+        description: "List sequences",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(getSecret(ctx), "GET", "/sequences"));
+            const courses = data.courses ?? [];
+            const { limit } = (input ?? {});
+            if (limit)
+                return courses.slice(0, limit);
+            return courses;
+        },
+    });
+    rl.registerAction("sequence.getSubscriptions", {
+        description: "List subscriptions for a sequence",
+        inputSchema: {
+            sequenceId: { type: "string", required: true, description: "Sequence ID" },
+            subscriberState: { type: "string", required: false, description: "Filter: active, cancelled" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { sequenceId, subscriberState, limit } = (input ?? {});
+            const qs = {};
+            if (subscriberState)
+                qs.subscriber_state = subscriberState;
+            const data = (await apiRequest(getSecret(ctx), "GET", `/sequences/${sequenceId}/subscriptions`, undefined, qs));
+            const subs = data.subscriptions ?? [];
+            if (limit)
+                return subs.slice(0, limit);
+            return subs;
+        },
+    });
+    // ── Tag ─────────────────────────────────────────────
+    rl.registerAction("tag.create", {
+        description: "Create one or more tags",
+        inputSchema: {
+            names: { type: "string", required: true, description: "Comma-separated tag names" },
+        },
+        async execute(input, ctx) {
+            const { names } = input;
+            const tag = names.split(",").map((n) => ({ name: n.trim() }));
+            return apiRequest(getSecret(ctx), "POST", "/tags", { tag });
+        },
+    });
+    rl.registerAction("tag.list", {
+        description: "List tags",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(getSecret(ctx), "GET", "/tags"));
+            const tags = data.tags ?? [];
+            const { limit } = (input ?? {});
+            if (limit)
+                return tags.slice(0, limit);
+            return tags;
+        },
+    });
+    // ── Tag Subscriber ──────────────────────────────────
+    rl.registerAction("tagSubscriber.add", {
+        description: "Tag a subscriber",
+        inputSchema: {
+            tagId: { type: "string", required: true, description: "Tag ID" },
+            email: { type: "string", required: true, description: "Subscriber email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            fields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { tagId, email, firstName, fields } = input;
+            const body = { email };
+            if (firstName)
+                body.first_name = firstName;
+            if (fields)
+                body.fields = fields;
+            const data = (await apiRequest(getSecret(ctx), "POST", `/tags/${tagId}/subscribe`, body));
+            return data.subscription;
+        },
+    });
+    rl.registerAction("tagSubscriber.list", {
+        description: "List subscribers for a tag",
+        inputSchema: {
+            tagId: { type: "string", required: true, description: "Tag ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { tagId, limit } = input;
+            const data = (await apiRequest(getSecret(ctx), "GET", `/tags/${tagId}/subscriptions`));
+            const subs = data.subscriptions ?? [];
+            if (limit)
+                return subs.slice(0, limit);
+            return subs;
+        },
+    });
+    rl.registerAction("tagSubscriber.remove", {
+        description: "Remove a tag from a subscriber",
+        inputSchema: {
+            tagId: { type: "string", required: true, description: "Tag ID" },
+            email: { type: "string", required: true, description: "Subscriber email" },
+        },
+        async execute(input, ctx) {
+            const { tagId, email } = input;
+            return apiRequest(getSecret(ctx), "POST", `/tags/${tagId}/unsubscribe`, { email });
+        },
+    });
+}

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

@@ -0,0 +1,140 @@
+const BASE_URL = "https://api.copper.com/developer_api/v1";
+async function apiRequest(apiKey, email, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "X-PW-AccessToken": apiKey,
+            "X-PW-Application": "developer_api",
+            "X-PW-UserEmail": email,
+        },
+    };
+    if (body && Object.keys(body).length > 0) {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Copper API error ${res.status}: ${await res.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 searchAll(apiKey, email, endpoint, body, limit) {
+    const results = [];
+    let page = 1;
+    const size = 200;
+    while (true) {
+        const data = (await apiRequest(apiKey, email, "POST", endpoint, {
+            ...body,
+            page_number: page,
+            page_size: size,
+        }));
+        if (!Array.isArray(data))
+            break;
+        results.push(...data);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (data.length < size)
+            break;
+        page++;
+    }
+    return results;
+}
+function getConn(ctx) {
+    return {
+        apiKey: ctx.connection.config.apiKey,
+        email: ctx.connection.config.email,
+    };
+}
+function registerCrud(rl, resource, endpoint, idParam, nameRequired, extraCreateFields) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: {
+            ...(nameRequired ? { name: { type: "string", required: true, description: `${resource} name` } } : {}),
+            ...extraCreateFields,
+        },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            return apiRequest(apiKey, email, "POST", endpoint, (input ?? {}));
+        },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ID`,
+        inputSchema: { [idParam]: { type: "string", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            return apiRequest(apiKey, email, "GET", `${endpoint}/${input[idParam]}`);
+        },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `Search/list ${resource}s`,
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            const { limit } = (input ?? {});
+            return searchAll(apiKey, email, `${endpoint}/search`, undefined, limit);
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: {
+            [idParam]: { type: "string", required: true, description: `${resource} ID` },
+        },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            const { [idParam]: id, ...body } = input;
+            return apiRequest(apiKey, email, "PUT", `${endpoint}/${id}`, body);
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { [idParam]: { type: "string", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            return apiRequest(apiKey, email, "DELETE", `${endpoint}/${input[idParam]}`);
+        },
+    });
+}
+export default function copper(rl) {
+    rl.setName("copper");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Copper API key", env: "COPPER_API_KEY" },
+        email: { type: "string", required: true, description: "Copper user email", env: "COPPER_EMAIL" },
+    });
+    // CRUD resources
+    registerCrud(rl, "company", "/companies", "companyId", true);
+    registerCrud(rl, "lead", "/leads", "leadId", true);
+    registerCrud(rl, "opportunity", "/opportunities", "opportunityId", true, {
+        customerSourceId: { type: "string", required: true, description: "Customer source ID" },
+        primaryContactId: { type: "string", required: true, description: "Primary contact ID" },
+    });
+    registerCrud(rl, "person", "/people", "personId", true);
+    registerCrud(rl, "project", "/projects", "projectId", true);
+    registerCrud(rl, "task", "/tasks", "taskId", true);
+    // Read-only resources
+    rl.registerAction("customerSource.list", {
+        description: "List customer sources",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            const data = (await apiRequest(apiKey, email, "GET", "/customer_sources"));
+            const { limit } = (input ?? {});
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { apiKey, email } = getConn(ctx);
+            const { limit } = (input ?? {});
+            return searchAll(apiKey, email, "/users/search", undefined, limit);
+        },
+    });
+}