runline 0.1.0

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

@@ -0,0 +1,200 @@
+const BASE = "https://api.securityscorecard.io";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}/${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Token ${token}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`SecurityScorecard error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function securityScorecard(rl) {
+    rl.setName("securityScorecard");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "SecurityScorecard API key", env: "SECURITYSCORECARD_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Company ─────────────────────────────────────────
+    rl.registerAction("company.getScorecard", {
+        description: "Get a company's scorecard by domain",
+        inputSchema: { domain: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `companies/${input.domain}`);
+        },
+    });
+    rl.registerAction("company.getFactors", {
+        description: "Get factor scores for a company",
+        inputSchema: { domain: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `companies/${p.domain}/factors`));
+            let entries = (data.entries ?? []);
+            if (p.limit)
+                entries = entries.slice(0, p.limit);
+            return entries;
+        },
+    });
+    rl.registerAction("company.getHistoricalScore", {
+        description: "Get historical score data for a company",
+        inputSchema: {
+            domain: { type: "string", required: true },
+            from: { type: "string", required: false, description: "Start date YYYY-MM-DD" },
+            to: { type: "string", required: false, description: "End date YYYY-MM-DD" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.from)
+                qs.from = p.from;
+            if (p.to)
+                qs.to = p.to;
+            const data = (await apiRequest(key(ctx), "GET", `companies/${p.domain}/history/factors/score`, undefined, qs));
+            let entries = (data.entries ?? []);
+            if (p.limit)
+                entries = entries.slice(0, p.limit);
+            return entries;
+        },
+    });
+    rl.registerAction("company.getScorePlan", {
+        description: "Get score improvement plan for a target score",
+        inputSchema: {
+            domain: { type: "string", required: true },
+            targetScore: { type: "number", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `companies/${p.domain}/score-plans/by-target/${p.targetScore}`));
+            return data.entries;
+        },
+    });
+    // ── Industry ────────────────────────────────────────
+    rl.registerAction("industry.getScore", {
+        description: "Get an industry's average score",
+        inputSchema: { industry: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `industries/${input.industry}/score`);
+        },
+    });
+    // ── Portfolio ───────────────────────────────────────
+    rl.registerAction("portfolio.create", {
+        description: "Create a portfolio",
+        inputSchema: {
+            name: { type: "string", required: true },
+            description: { type: "string", required: true },
+            privacy: { type: "string", required: true, description: "private or shared" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", "portfolios", { name: p.name, description: p.description, privacy: p.privacy });
+        },
+    });
+    rl.registerAction("portfolio.list", {
+        description: "List all portfolios",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "GET", "portfolios"));
+            let entries = (data.entries ?? []);
+            if (input?.limit)
+                entries = entries.slice(0, input.limit);
+            return entries;
+        },
+    });
+    rl.registerAction("portfolio.delete", {
+        description: "Delete a portfolio",
+        inputSchema: { portfolioId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `portfolios/${input.portfolioId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("portfolioCompany.add", {
+        description: "Add a company to a portfolio",
+        inputSchema: { portfolioId: { type: "string", required: true }, domain: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `portfolios/${p.portfolioId}/companies/${p.domain}`);
+        },
+    });
+    rl.registerAction("portfolioCompany.remove", {
+        description: "Remove a company from a portfolio",
+        inputSchema: { portfolioId: { type: "string", required: true }, domain: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await apiRequest(key(ctx), "DELETE", `portfolios/${p.portfolioId}/companies/${p.domain}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("portfolioCompany.list", {
+        description: "List companies in a portfolio",
+        inputSchema: { portfolioId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `portfolios/${p.portfolioId}/companies`));
+            let entries = (data.entries ?? []);
+            if (p.limit)
+                entries = entries.slice(0, p.limit);
+            return entries;
+        },
+    });
+    // ── Invite ──────────────────────────────────────────
+    rl.registerAction("invite.create", {
+        description: "Send an invitation",
+        inputSchema: {
+            email: { type: "string", required: true },
+            firstName: { type: "string", required: true },
+            lastName: { type: "string", required: true },
+            message: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", "invitations", {
+                email: p.email, first_name: p.firstName, last_name: p.lastName, message: p.message,
+            });
+        },
+    });
+    // ── Report ──────────────────────────────────────────
+    rl.registerAction("report.generate", {
+        description: "Generate a report",
+        inputSchema: {
+            reportType: { type: "string", required: true, description: "Report type: detailed, summary, issues, portfolio, events-json, full-scorecard-json, scorecard-footprint" },
+            scorecardIdentifier: { type: "string", required: false, description: "Company domain (for non-portfolio reports)" },
+            portfolioId: { type: "string", required: false, description: "Portfolio ID (for portfolio reports)" },
+            format: { type: "string", required: false, description: "pdf or csv (for issues/portfolio)" },
+            branding: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {};
+            if (p.reportType !== "portfolio")
+                body.scorecard_identifier = p.scorecardIdentifier;
+            else
+                body.portfolio_id = p.portfolioId;
+            if (p.format)
+                body.format = p.format;
+            if (p.branding)
+                body.branding = p.branding;
+            return apiRequest(key(ctx), "POST", `reports/${p.reportType}`, body);
+        },
+    });
+    rl.registerAction("report.list", {
+        description: "List recent reports",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "GET", "reports/recent"));
+            let entries = (data.entries ?? []);
+            if (input?.limit)
+                entries = entries.slice(0, input.limit);
+            return entries;
+        },
+    });
+}

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

@@ -0,0 +1,125 @@
+const BASE = "https://api.segment.io/v1";
+async function apiRequest(writeKey, endpoint, body) {
+    const res = await fetch(`${BASE}${endpoint}`, {
+        method: "POST",
+        headers: {
+            Authorization: "Basic " + btoa(`${writeKey}:`),
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Segment error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function segment(rl) {
+    rl.setName("segment");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        writeKey: { type: "string", required: true, description: "Segment source write key", env: "SEGMENT_WRITE_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.writeKey;
+    rl.registerAction("identify.create", {
+        description: "Identify a user (tie user to traits)",
+        inputSchema: {
+            userId: { type: "string", required: false, description: "User ID (or anonymousId will be generated)" },
+            anonymousId: { type: "string", required: false },
+            traits: { type: "object", required: false, description: "User traits key-value pairs" },
+            context: { type: "object", required: false },
+            integrations: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.userId)
+                body.userId = p.userId;
+            else
+                body.anonymousId = p.anonymousId ?? crypto.randomUUID();
+            if (p.traits)
+                body.traits = p.traits;
+            if (p.context)
+                body.context = p.context;
+            if (p.integrations)
+                body.integrations = p.integrations;
+            return apiRequest(key(ctx), "/identify", body);
+        },
+    });
+    rl.registerAction("track.event", {
+        description: "Track an event",
+        inputSchema: {
+            event: { type: "string", required: true, description: "Event name" },
+            userId: { type: "string", required: false },
+            anonymousId: { type: "string", required: false },
+            properties: { type: "object", required: false, description: "Event properties" },
+            context: { type: "object", required: false },
+            integrations: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { event: p.event };
+            if (p.userId)
+                body.userId = p.userId;
+            else
+                body.anonymousId = p.anonymousId ?? crypto.randomUUID();
+            if (p.properties)
+                body.properties = p.properties;
+            if (p.context)
+                body.context = p.context;
+            if (p.integrations)
+                body.integrations = p.integrations;
+            return apiRequest(key(ctx), "/track", body);
+        },
+    });
+    rl.registerAction("track.page", {
+        description: "Track a page view",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Page name" },
+            userId: { type: "string", required: false },
+            anonymousId: { type: "string", required: false },
+            properties: { type: "object", required: false },
+            context: { type: "object", required: false },
+            integrations: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { name: p.name };
+            if (p.userId)
+                body.userId = p.userId;
+            else
+                body.anonymousId = p.anonymousId ?? crypto.randomUUID();
+            if (p.properties)
+                body.properties = p.properties;
+            if (p.context)
+                body.context = p.context;
+            if (p.integrations)
+                body.integrations = p.integrations;
+            return apiRequest(key(ctx), "/page", body);
+        },
+    });
+    rl.registerAction("group.add", {
+        description: "Associate a user with a group",
+        inputSchema: {
+            groupId: { type: "string", required: true },
+            userId: { type: "string", required: false },
+            anonymousId: { type: "string", required: false },
+            traits: { type: "object", required: false, description: "Group traits" },
+            context: { type: "object", required: false },
+            integrations: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { groupId: p.groupId };
+            if (p.userId)
+                body.userId = p.userId;
+            else
+                body.anonymousId = p.anonymousId ?? crypto.randomUUID();
+            if (p.traits)
+                body.traits = p.traits;
+            if (p.context)
+                body.context = p.context;
+            if (p.integrations)
+                body.integrations = p.integrations;
+            return apiRequest(key(ctx), "/group", body);
+        },
+    });
+}

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

@@ -0,0 +1,187 @@
+const BASE = "https://api.sendgrid.com/v3";
+async function apiRequest(apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = { method, headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" } };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok && res.status !== 202)
+        throw new Error(`SendGrid error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    const headers = {};
+    res.headers.forEach((v, k) => { headers[k] = v; });
+    return { data: text ? JSON.parse(text) : {}, headers };
+}
+export default function sendgrid(rl) {
+    rl.setName("sendgrid");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "SendGrid API key", env: "SENDGRID_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Mail ────────────────────────────────────────────
+    rl.registerAction("mail.send", {
+        description: "Send an email via SendGrid",
+        inputSchema: {
+            to: { type: "string", required: true, description: "Recipient email(s), comma-separated" },
+            from: { type: "string", required: true, description: "Sender email" },
+            fromName: { type: "string", required: false },
+            subject: { type: "string", required: true },
+            contentType: { type: "string", required: false, description: "text/plain or text/html (default text/plain)" },
+            content: { type: "string", required: true, description: "Email body" },
+            cc: { type: "string", required: false, description: "CC emails, comma-separated" },
+            bcc: { type: "string", required: false, description: "BCC emails, comma-separated" },
+            replyTo: { type: "string", required: false },
+            templateId: { type: "string", required: false, description: "Dynamic template ID (overrides subject/content)" },
+            dynamicTemplateData: { type: "object", required: false, description: "Template variables" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const toList = p.to.split(",").map(e => ({ email: e.trim() }));
+            const personalization = { to: toList };
+            const body = {
+                personalizations: [personalization],
+                from: { email: p.from.trim(), name: p.fromName },
+            };
+            if (p.templateId) {
+                body.template_id = p.templateId;
+                if (p.dynamicTemplateData)
+                    personalization.dynamic_template_data = p.dynamicTemplateData;
+            }
+            else {
+                personalization.subject = p.subject;
+                body.content = [{ type: p.contentType ?? "text/plain", value: p.content }];
+            }
+            if (p.cc)
+                personalization.cc = p.cc.split(",").map(e => ({ email: e.trim() }));
+            if (p.bcc)
+                personalization.bcc = p.bcc.split(",").map(e => ({ email: e.trim() }));
+            if (p.replyTo)
+                body.reply_to_list = p.replyTo.split(",").map(e => ({ email: e.trim() }));
+            const { headers } = await apiRequest(key(ctx), "POST", "/mail/send", body);
+            return { messageId: headers["x-message-id"] ?? null };
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID or email",
+        inputSchema: {
+            contactId: { type: "string", required: false },
+            email: { type: "string", required: false, description: "Email (searches if no contactId)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            if (p.contactId) {
+                const { data } = await apiRequest(key(ctx), "GET", `/marketing/contacts/${p.contactId}`);
+                return data;
+            }
+            const { data } = await apiRequest(key(ctx), "POST", "/marketing/contacts/search", { query: `email LIKE '${p.email}'` });
+            const result = data.result;
+            return result?.[0];
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts (optionally with SGQL query)",
+        inputSchema: {
+            query: { type: "string", required: false, description: "SGQL query filter" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            let endpoint = "/marketing/contacts";
+            let method = "GET";
+            const body = {};
+            if (p.query) {
+                endpoint = "/marketing/contacts/search";
+                method = "POST";
+                body.query = p.query;
+            }
+            const { data } = await apiRequest(key(ctx), method, endpoint, Object.keys(body).length ? body : undefined);
+            let result = (data.result ?? []);
+            if (p.limit)
+                result = result.slice(0, p.limit);
+            return result;
+        },
+    });
+    rl.registerAction("contact.upsert", {
+        description: "Create or update contacts",
+        inputSchema: {
+            contacts: { type: "object", required: true, description: "Array of contact objects [{email, first_name?, last_name?, ...}]" },
+            listIds: { type: "object", required: false, description: "Array of list IDs to add contacts to" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { contacts: p.contacts };
+            if (p.listIds)
+                body.list_ids = p.listIds;
+            const { data } = await apiRequest(key(ctx), "PUT", "/marketing/contacts", body);
+            return data;
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete contacts by IDs",
+        inputSchema: {
+            ids: { type: "string", required: true, description: "Comma-separated contact IDs" },
+        },
+        async execute(input, ctx) {
+            const { ids } = input;
+            const { data } = await apiRequest(key(ctx), "DELETE", "/marketing/contacts", undefined, { ids });
+            return data;
+        },
+    });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.create", {
+        description: "Create a contact list",
+        inputSchema: { name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { data } = await apiRequest(key(ctx), "POST", "/marketing/lists", { name: input.name });
+            return data;
+        },
+    });
+    rl.registerAction("list.get", {
+        description: "Get a list by ID",
+        inputSchema: { listId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { data } = await apiRequest(key(ctx), "GET", `/marketing/lists/${input.listId}`);
+            return data;
+        },
+    });
+    rl.registerAction("list.list", {
+        description: "List all contact lists",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { data } = await apiRequest(key(ctx), "GET", "/marketing/lists");
+            let result = (data.result ?? []);
+            if (input?.limit)
+                result = result.slice(0, input.limit);
+            return result;
+        },
+    });
+    rl.registerAction("list.update", {
+        description: "Update a list name",
+        inputSchema: { listId: { type: "string", required: true }, name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const { data } = await apiRequest(key(ctx), "PATCH", `/marketing/lists/${p.listId}`, { name: p.name });
+            return data;
+        },
+    });
+    rl.registerAction("list.delete", {
+        description: "Delete a list",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            deleteContacts: { type: "boolean", required: false, description: "Also delete contacts in list" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            await apiRequest(key(ctx), "DELETE", `/marketing/lists/${p.listId}`, undefined, { delete_contacts: p.deleteContacts ? "true" : "false" });
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,138 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), apiKey: c.apiKey };
+}
+async function apiRequest(conn, endpoint, body) {
+    body.api_key = conn.apiKey;
+    body.boolean = true;
+    const formBody = Object.entries(body)
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+        .join("&");
+    const res = await fetch(`${conn.url}${endpoint}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: formBody,
+    });
+    if (!res.ok)
+        throw new Error(`Sendy error ${res.status}: ${await res.text()}`);
+    return res.text();
+}
+export default function sendy(rl) {
+    rl.setName("sendy");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Sendy installation URL", env: "SENDY_URL" },
+        apiKey: { type: "string", required: true, description: "Sendy API key", env: "SENDY_API_KEY" },
+    });
+    rl.registerAction("campaign.create", {
+        description: "Create (and optionally send) an email campaign",
+        inputSchema: {
+            fromName: { type: "string", required: true },
+            fromEmail: { type: "string", required: true },
+            replyTo: { type: "string", required: true },
+            title: { type: "string", required: true },
+            subject: { type: "string", required: true },
+            htmlText: { type: "string", required: true, description: "HTML content of the email" },
+            sendCampaign: { type: "boolean", required: false, description: "Send immediately (default false)" },
+            brandId: { type: "string", required: false, description: "Brand ID (required if not sending)" },
+            listIds: { type: "string", required: false, description: "Comma-separated list IDs" },
+            plainText: { type: "string", required: false },
+            trackOpens: { type: "boolean", required: false },
+            trackClicks: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                from_name: p.fromName, from_email: p.fromEmail, reply_to: p.replyTo,
+                title: p.title, subject: p.subject, html_text: p.htmlText,
+                send_campaign: p.sendCampaign ? 1 : 0,
+            };
+            if (p.brandId)
+                body.brand_id = p.brandId;
+            if (p.listIds)
+                body.list_ids = p.listIds;
+            if (p.plainText)
+                body.plain_text = p.plainText;
+            if (p.trackOpens !== undefined)
+                body.track_opens = p.trackOpens ? 1 : 0;
+            if (p.trackClicks !== undefined)
+                body.track_clicks = p.trackClicks ? 1 : 0;
+            const resp = await apiRequest(getConn(ctx), "/api/campaigns/create.php", body);
+            if (resp.includes("Campaign created"))
+                return { message: resp };
+            throw new Error(`Sendy campaign error: ${resp}`);
+        },
+    });
+    rl.registerAction("subscriber.add", {
+        description: "Add a subscriber to a list",
+        inputSchema: {
+            email: { type: "string", required: true },
+            listId: { type: "string", required: true },
+            name: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { email: p.email, list: p.listId };
+            if (p.name)
+                body.name = p.name;
+            const resp = await apiRequest(getConn(ctx), "/subscribe", body);
+            if (resp === "1")
+                return { success: true };
+            throw new Error(`Sendy subscribe error: ${resp}`);
+        },
+    });
+    rl.registerAction("subscriber.count", {
+        description: "Get active subscriber count for a list",
+        inputSchema: { listId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { listId } = input;
+            const resp = await apiRequest(getConn(ctx), "/api/subscribers/active-subscriber-count.php", { list_id: listId });
+            if (/^\d+$/.test(resp))
+                return { count: parseInt(resp, 10) };
+            throw new Error(`Sendy count error: ${resp}`);
+        },
+    });
+    rl.registerAction("subscriber.delete", {
+        description: "Delete a subscriber from a list",
+        inputSchema: {
+            email: { type: "string", required: true },
+            listId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { email, listId } = input;
+            const resp = await apiRequest(getConn(ctx), "/api/subscribers/delete.php", { email, list_id: listId });
+            if (resp === "1")
+                return { success: true };
+            throw new Error(`Sendy delete error: ${resp}`);
+        },
+    });
+    rl.registerAction("subscriber.unsubscribe", {
+        description: "Unsubscribe an email from a list",
+        inputSchema: {
+            email: { type: "string", required: true },
+            listId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { email, listId } = input;
+            const resp = await apiRequest(getConn(ctx), "/unsubscribe", { email, list: listId });
+            if (resp === "1")
+                return { success: true };
+            throw new Error(`Sendy unsubscribe error: ${resp}`);
+        },
+    });
+    rl.registerAction("subscriber.status", {
+        description: "Get subscription status of an email",
+        inputSchema: {
+            email: { type: "string", required: true },
+            listId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { email, listId } = input;
+            const resp = await apiRequest(getConn(ctx), "/api/subscribers/subscription-status.php", { email, list_id: listId });
+            const valid = ["Subscribed", "Unsubscribed", "Unconfirmed", "Bounced", "Soft bounced", "Complained"];
+            if (valid.includes(resp))
+                return { status: resp };
+            throw new Error(`Sendy status error: ${resp}`);
+        },
+    });
+}