runline 0.1.0

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

@@ -0,0 +1,331 @@
+async function apiRequest(baseUrl, token, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}/api/v4/${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: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+    };
+    if (body !== undefined && method !== "GET" && method !== "DELETE") {
+        opts.body = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Mattermost API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginateAll(baseUrl, token, endpoint, qs = {}) {
+    const all = [];
+    qs.page = 0;
+    qs.per_page = 100;
+    let data;
+    do {
+        data = (await apiRequest(baseUrl, token, "GET", endpoint, undefined, qs));
+        all.push(...data);
+        qs.page++;
+    } while (data.length > 0);
+    return all;
+}
+export default function mattermost(rl) {
+    rl.setName("mattermost");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: true, description: "Mattermost server URL (e.g. https://mattermost.example.com)", env: "MATTERMOST_URL" },
+        accessToken: { type: "string", required: true, description: "Personal access token or bot token", env: "MATTERMOST_TOKEN" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: ctx.connection.config.baseUrl.replace(/\/$/, ""),
+        token: ctx.connection.config.accessToken,
+    });
+    // ── Channel ─────────────────────────────────────────
+    rl.registerAction("channel.create", {
+        description: "Create a channel",
+        inputSchema: {
+            teamId: { type: "string", required: true },
+            displayName: { type: "string", required: true, description: "Display name" },
+            name: { type: "string", required: true, description: "URL-safe channel name" },
+            type: { type: "string", required: true, description: "'public' or 'private'" },
+        },
+        async execute(input, ctx) {
+            const { teamId, displayName, name, type } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", "channels", {
+                team_id: teamId, display_name: displayName, name, type: type === "public" ? "O" : "P",
+            });
+        },
+    });
+    rl.registerAction("channel.delete", {
+        description: "Delete (archive) a channel",
+        inputSchema: { channelId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "DELETE", `channels/${input.channelId}`);
+        },
+    });
+    rl.registerAction("channel.addUser", {
+        description: "Add a user to a channel",
+        inputSchema: { channelId: { type: "string", required: true }, userId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { channelId, userId } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", `channels/${channelId}/members`, { user_id: userId });
+        },
+    });
+    rl.registerAction("channel.members", {
+        description: "List members of a channel",
+        inputSchema: {
+            channelId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+            resolveData: { type: "boolean", required: false, description: "Resolve user IDs to full user objects" },
+        },
+        async execute(input, ctx) {
+            const { channelId, limit, resolveData } = (input ?? {});
+            const { baseUrl, token } = conn(ctx);
+            let data;
+            if (limit) {
+                data = (await apiRequest(baseUrl, token, "GET", `channels/${channelId}/members`, undefined, { per_page: limit }));
+            }
+            else {
+                data = await paginateAll(baseUrl, token, `channels/${channelId}/members`);
+            }
+            if (resolveData && data.length > 0) {
+                const userIds = data.map((m) => m.user_id);
+                return apiRequest(baseUrl, token, "POST", "users/ids", userIds);
+            }
+            return data;
+        },
+    });
+    rl.registerAction("channel.restore", {
+        description: "Restore (unarchive) a channel",
+        inputSchema: { channelId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", `channels/${input.channelId}/restore`);
+        },
+    });
+    rl.registerAction("channel.search", {
+        description: "Search channels in a team",
+        inputSchema: {
+            teamId: { type: "string", required: true },
+            term: { type: "string", required: true, description: "Search term" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { teamId, term, limit } = input;
+            const { baseUrl, token } = conn(ctx);
+            let data = (await apiRequest(baseUrl, token, "POST", `teams/${teamId}/channels/search`, { term }));
+            if (limit)
+                data = data.slice(0, limit);
+            return data;
+        },
+    });
+    rl.registerAction("channel.statistics", {
+        description: "Get channel statistics",
+        inputSchema: { channelId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `channels/${input.channelId}/stats`);
+        },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.post", {
+        description: "Post a message to a channel",
+        inputSchema: {
+            channelId: { type: "string", required: true },
+            message: { type: "string", required: true },
+            attachments: { type: "array", required: false, description: "Array of Mattermost attachment objects" },
+            rootId: { type: "string", required: false, description: "Post ID to reply to (thread)" },
+        },
+        async execute(input, ctx) {
+            const { channelId, message, attachments, rootId } = input;
+            const { baseUrl, token } = conn(ctx);
+            const body = { channel_id: channelId, message };
+            if (attachments)
+                body.props = { attachments };
+            if (rootId)
+                body.root_id = rootId;
+            return apiRequest(baseUrl, token, "POST", "posts", body);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message (post)",
+        inputSchema: { postId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "DELETE", `posts/${input.postId}`);
+        },
+    });
+    rl.registerAction("message.postEphemeral", {
+        description: "Post an ephemeral message (visible only to one user)",
+        inputSchema: {
+            channelId: { type: "string", required: true },
+            userId: { type: "string", required: true, description: "User who will see the message" },
+            message: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { channelId, userId, message } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", "posts/ephemeral", {
+                user_id: userId,
+                post: { channel_id: channelId, message },
+            });
+        },
+    });
+    // ── Reaction ────────────────────────────────────────
+    rl.registerAction("reaction.create", {
+        description: "Add a reaction to a post",
+        inputSchema: {
+            userId: { type: "string", required: true },
+            postId: { type: "string", required: true },
+            emojiName: { type: "string", required: true, description: "Emoji name without colons (e.g. 'thumbsup')" },
+        },
+        async execute(input, ctx) {
+            const { userId, postId, emojiName } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", "reactions", {
+                user_id: userId,
+                post_id: postId,
+                emoji_name: emojiName.replace(/:/g, ""),
+                create_at: Date.now(),
+            });
+        },
+    });
+    rl.registerAction("reaction.delete", {
+        description: "Remove a reaction from a post",
+        inputSchema: {
+            userId: { type: "string", required: true },
+            postId: { type: "string", required: true },
+            emojiName: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { userId, postId, emojiName } = input;
+            const { baseUrl, token } = conn(ctx);
+            const name = emojiName.replace(/:/g, "");
+            return apiRequest(baseUrl, token, "DELETE", `users/${userId}/posts/${postId}/reactions/${name}`);
+        },
+    });
+    rl.registerAction("reaction.list", {
+        description: "List reactions on a post",
+        inputSchema: {
+            postId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const { postId, limit } = input;
+            const { baseUrl, token } = conn(ctx);
+            let data = (await apiRequest(baseUrl, token, "GET", `posts/${postId}/reactions`));
+            if (data === null)
+                return [];
+            if (limit)
+                data = data.slice(0, limit);
+            return data;
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Create a user",
+        inputSchema: {
+            username: { type: "string", required: true },
+            authService: { type: "string", required: true, description: "'email' for email/password, or an SSO service name" },
+            email: { type: "string", required: false, description: "Required if authService is 'email'" },
+            password: { type: "string", required: false, description: "Required if authService is 'email'" },
+            authData: { type: "string", required: false, description: "Required if authService is not 'email'" },
+            additionalFields: { type: "object", required: false, description: "first_name, last_name, nickname, locale, position, etc." },
+        },
+        async execute(input, ctx) {
+            const { username, authService, email, password, authData, additionalFields } = input;
+            const { baseUrl, token } = conn(ctx);
+            const body = { username, auth_service: authService };
+            if (authService === "email") {
+                body.email = email;
+                body.password = password;
+            }
+            else {
+                body.auth_data = authData;
+            }
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            return apiRequest(baseUrl, token, "POST", "users", body);
+        },
+    });
+    rl.registerAction("user.deactivate", {
+        description: "Deactivate (delete) a user",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "DELETE", `users/${input.userId}`);
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            inTeam: { type: "string", required: false, description: "Filter by team ID" },
+            notInTeam: { type: "string", required: false },
+            inChannel: { type: "string", required: false, description: "Filter by channel ID" },
+            notInChannel: { type: "string", required: false },
+            sort: { type: "string", required: false, description: "last_activity_at, created_at, username, status" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const { baseUrl, token } = conn(ctx);
+            const qs = {};
+            if (p.inTeam)
+                qs.in_team = p.inTeam;
+            if (p.notInTeam)
+                qs.not_in_team = p.notInTeam;
+            if (p.inChannel)
+                qs.in_channel = p.inChannel;
+            if (p.notInChannel)
+                qs.not_in_channel = p.notInChannel;
+            if (p.sort && p.sort !== "username")
+                qs.sort = p.sort;
+            if (p.limit) {
+                qs.per_page = p.limit;
+                return apiRequest(baseUrl, token, "GET", "users", undefined, qs);
+            }
+            return paginateAll(baseUrl, token, "users", qs);
+        },
+    });
+    rl.registerAction("user.getByEmail", {
+        description: "Get a user by email",
+        inputSchema: { email: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `users/email/${input.email}`);
+        },
+    });
+    rl.registerAction("user.getByIds", {
+        description: "Get users by IDs",
+        inputSchema: {
+            userIds: { type: "array", required: true, description: "Array of user IDs" },
+            since: { type: "string", required: false, description: "ISO datetime — only return users updated since" },
+        },
+        async execute(input, ctx) {
+            const { userIds, since } = input;
+            const { baseUrl, token } = conn(ctx);
+            const qs = {};
+            if (since)
+                qs.since = new Date(since).getTime();
+            return apiRequest(baseUrl, token, "POST", "users/ids", userIds, qs);
+        },
+    });
+    rl.registerAction("user.invite", {
+        description: "Invite users to a team by email",
+        inputSchema: {
+            teamId: { type: "string", required: true },
+            emails: { type: "array", required: true, description: "Array of email addresses" },
+        },
+        async execute(input, ctx) {
+            const { teamId, emails } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", `teams/${teamId}/invite/email`, emails);
+        },
+    });
+}

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

@@ -0,0 +1,311 @@
+async function apiRequest(baseUrl, username, password, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}/api${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(`${username}:${password}`)}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Mautic API error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.errors)
+        throw new Error(`Mautic API error: ${JSON.stringify(data.errors)}`);
+    return data;
+}
+async function paginateAll(baseUrl, username, password, propertyName, endpoint, qs = {}) {
+    const all = [];
+    qs.limit = 30;
+    qs.start = 0;
+    let data;
+    do {
+        data = (await apiRequest(baseUrl, username, password, "GET", endpoint, undefined, qs));
+        const values = Object.values((data[propertyName] ?? {}));
+        all.push(...values);
+        qs.start += qs.limit;
+    } while (data.total !== undefined && all.length < Number.parseInt(data.total, 10));
+    return all;
+}
+export default function mautic(rl) {
+    rl.setName("mautic");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Mautic instance URL (e.g. https://mautic.example.com)", env: "MAUTIC_URL" },
+        username: { type: "string", required: true, description: "Mautic username", env: "MAUTIC_USERNAME" },
+        password: { type: "string", required: true, description: "Mautic password", env: "MAUTIC_PASSWORD" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: ctx.connection.config.url.replace(/\/$/, ""),
+        username: ctx.connection.config.username,
+        password: ctx.connection.config.password,
+    });
+    const req = (ctx, method, endpoint, body, qs) => {
+        const c = conn(ctx);
+        return apiRequest(c.baseUrl, c.username, c.password, method, endpoint, body, qs);
+    };
+    const pagAll = (ctx, prop, endpoint, qs) => {
+        const c = conn(ctx);
+        return paginateAll(c.baseUrl, c.username, c.password, prop, endpoint, qs);
+    };
+    // ── Company ─────────────────────────────────────────
+    rl.registerAction("company.create", {
+        description: "Create a company",
+        inputSchema: {
+            companyname: { type: "string", required: true },
+            additionalFields: { type: "object", required: false, description: "companyemail, companyfax, companyindustry, companyphone, companywebsite, companyannual_revenue, companydescription, companynumber_of_employees, companyaddress1, companyaddress2, companycity, companystate, companycountry, companyzipcode, custom fields" },
+        },
+        async execute(input, ctx) {
+            const { companyname, additionalFields } = input;
+            const body = { companyname };
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/companies/new", body));
+            return data.company;
+        },
+    });
+    rl.registerAction("company.update", {
+        description: "Update a company",
+        inputSchema: {
+            companyId: { type: "string", required: true },
+            updateFields: { type: "object", required: true, description: "Fields to update (same keys as create)" },
+        },
+        async execute(input, ctx) {
+            const { companyId, updateFields } = input;
+            const data = (await req(ctx, "PATCH", `/companies/${companyId}/edit`, updateFields));
+            return data.company;
+        },
+    });
+    rl.registerAction("company.get", {
+        description: "Get a company by ID",
+        inputSchema: { companyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/companies/${input.companyId}`));
+            return data.company;
+        },
+    });
+    rl.registerAction("company.list", {
+        description: "List companies",
+        inputSchema: { limit: { type: "number", required: false }, search: { type: "string", required: false }, orderBy: { type: "string", required: false }, orderByDir: { type: "string", required: false, description: "ASC or DESC" } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.search)
+                qs.search = p.search;
+            if (p.orderBy)
+                qs.orderBy = p.orderBy;
+            if (p.orderByDir)
+                qs.orderByDir = p.orderByDir;
+            if (p.limit) {
+                qs.limit = p.limit;
+                qs.start = 0;
+                const data = (await req(ctx, "GET", "/companies", undefined, qs));
+                return Object.values((data.companies ?? {}));
+            }
+            return pagAll(ctx, "companies", "/companies", qs);
+        },
+    });
+    rl.registerAction("company.delete", {
+        description: "Delete a company",
+        inputSchema: { companyId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "DELETE", `/companies/${input.companyId}/delete`));
+            return data.company;
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: {
+            email: { type: "string", required: false },
+            firstname: { type: "string", required: false },
+            lastname: { type: "string", required: false },
+            company: { type: "string", required: false },
+            position: { type: "string", required: false },
+            title: { type: "string", required: false },
+            phone: { type: "string", required: false },
+            mobile: { type: "string", required: false },
+            website: { type: "string", required: false },
+            tags: { type: "string", required: false, description: "Comma-separated tags" },
+            stage: { type: "string", required: false, description: "Stage ID" },
+            owner: { type: "string", required: false, description: "Owner user ID" },
+            ipAddress: { type: "string", required: false },
+            additionalFields: { type: "object", required: false, description: "Custom fields, address fields (address1, address2, city, state, country, zipcode), social (facebook, twitter, linkedin, skype, instagram, foursquare)" },
+        },
+        async execute(input, ctx) {
+            const { additionalFields, ...rest } = input;
+            const body = {};
+            for (const [k, v] of Object.entries(rest)) {
+                if (v !== undefined && v !== null && v !== "")
+                    body[k] = v;
+            }
+            if (additionalFields)
+                Object.assign(body, additionalFields);
+            const data = (await req(ctx, "POST", "/contacts/new", body));
+            return data.contact;
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true },
+            updateFields: { type: "object", required: true, description: "Fields to update (email, firstname, lastname, company, position, title, phone, mobile, address fields, social fields, custom fields, tags, stage, owner, etc.)" },
+        },
+        async execute(input, ctx) {
+            const { contactId, updateFields } = input;
+            const data = (await req(ctx, "PATCH", `/contacts/${contactId}/edit`, updateFields));
+            return data.contact;
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: { contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "GET", `/contacts/${input.contactId}`));
+            return data.contact;
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            search: { type: "string", required: false },
+            orderBy: { type: "string", required: false, description: "Field to order by (snake_case)" },
+            orderByDir: { type: "string", required: false, description: "ASC or DESC" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.search)
+                qs.search = p.search;
+            if (p.orderBy)
+                qs.orderBy = p.orderBy;
+            if (p.orderByDir)
+                qs.orderByDir = p.orderByDir;
+            if (p.limit) {
+                qs.limit = p.limit;
+                qs.start = 0;
+                const data = (await req(ctx, "GET", "/contacts", undefined, qs));
+                return Object.values((data.contacts ?? {}));
+            }
+            return pagAll(ctx, "contacts", "/contacts", qs);
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: { contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await req(ctx, "DELETE", `/contacts/${input.contactId}/delete`));
+            return data.contact;
+        },
+    });
+    rl.registerAction("contact.sendEmail", {
+        description: "Send a campaign/template email to a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true },
+            emailId: { type: "string", required: true, description: "Campaign email ID (template type)" },
+        },
+        async execute(input, ctx) {
+            const { contactId, emailId } = input;
+            return req(ctx, "POST", `/emails/${emailId}/contact/${contactId}/send`);
+        },
+    });
+    rl.registerAction("contact.editDoNotContact", {
+        description: "Add or remove a contact from the Do Not Contact list",
+        inputSchema: {
+            contactId: { type: "string", required: true },
+            channel: { type: "string", required: true, description: "email, sms, etc." },
+            action: { type: "string", required: true, description: "'add' or 'remove'" },
+            reason: { type: "number", required: false, description: "DNC reason (1=contacted, 2=unsubscribed, 3=bounced, 4=manual)" },
+            comments: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { contactId, channel, action, reason, comments } = input;
+            const body = {};
+            if (reason)
+                body.reason = reason;
+            if (comments)
+                body.comments = comments;
+            const data = (await req(ctx, "POST", `/contacts/${contactId}/dnc/${channel}/${action}`, body));
+            return data.contact;
+        },
+    });
+    rl.registerAction("contact.editPoints", {
+        description: "Add or subtract points from a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true },
+            action: { type: "string", required: true, description: "'add' or 'subtract'" },
+            points: { type: "number", required: true },
+        },
+        async execute(input, ctx) {
+            const { contactId, action, points } = input;
+            const path = action === "add" ? "plus" : "minus";
+            return req(ctx, "POST", `/contacts/${contactId}/points/${path}/${points}`);
+        },
+    });
+    // ── Contact Segment ─────────────────────────────────
+    rl.registerAction("contactSegment.add", {
+        description: "Add a contact to a segment",
+        inputSchema: { segmentId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { segmentId, contactId } = input;
+            return req(ctx, "POST", `/segments/${segmentId}/contact/${contactId}/add`);
+        },
+    });
+    rl.registerAction("contactSegment.remove", {
+        description: "Remove a contact from a segment",
+        inputSchema: { segmentId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { segmentId, contactId } = input;
+            return req(ctx, "POST", `/segments/${segmentId}/contact/${contactId}/remove`);
+        },
+    });
+    // ── Campaign Contact ────────────────────────────────
+    rl.registerAction("campaignContact.add", {
+        description: "Add a contact to a campaign",
+        inputSchema: { campaignId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { campaignId, contactId } = input;
+            return req(ctx, "POST", `/campaigns/${campaignId}/contact/${contactId}/add`);
+        },
+    });
+    rl.registerAction("campaignContact.remove", {
+        description: "Remove a contact from a campaign",
+        inputSchema: { campaignId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { campaignId, contactId } = input;
+            return req(ctx, "POST", `/campaigns/${campaignId}/contact/${contactId}/remove`);
+        },
+    });
+    // ── Company Contact ─────────────────────────────────
+    rl.registerAction("companyContact.add", {
+        description: "Add a contact to a company",
+        inputSchema: { companyId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { companyId, contactId } = input;
+            return req(ctx, "POST", `/companies/${companyId}/contact/${contactId}/add`);
+        },
+    });
+    rl.registerAction("companyContact.remove", {
+        description: "Remove a contact from a company",
+        inputSchema: { companyId: { type: "string", required: true }, contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { companyId, contactId } = input;
+            return req(ctx, "POST", `/companies/${companyId}/contact/${contactId}/remove`);
+        },
+    });
+    // ── Segment Email ───────────────────────────────────
+    rl.registerAction("segmentEmail.send", {
+        description: "Send a segment (list) email",
+        inputSchema: { emailId: { type: "string", required: true, description: "Segment email ID" } },
+        async execute(input, ctx) {
+            return req(ctx, "POST", `/emails/${input.emailId}/send`);
+        },
+    });
+}