runline 0.1.0

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

@@ -0,0 +1,174 @@
+const GQL_URL = "https://graphql.emelia.io/graphql";
+async function gql(apiKey, query, variables) {
+    const body = { query };
+    if (variables)
+        body.variables = variables;
+    const res = await fetch(GQL_URL, {
+        method: "POST",
+        headers: {
+            Authorization: apiKey,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Emelia API error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.errors)
+        throw new Error(`Emelia GraphQL error: ${JSON.stringify(data.errors)}`);
+    return data.data;
+}
+export default function emelia(rl) {
+    rl.setName("emelia");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Emelia API key", env: "EMELIA_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Campaign ────────────────────────────────────────
+    rl.registerAction("campaign.create", {
+        description: "Create a new campaign",
+        inputSchema: { name: { type: "string", required: true, description: "Campaign name" } },
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `
+        mutation createCampaign($name: String!) {
+          createCampaign(name: $name) { _id name status createdAt provider startAt estimatedEnd }
+        }`, { name: input.name });
+            return data.createCampaign;
+        },
+    });
+    rl.registerAction("campaign.get", {
+        description: "Get a campaign by ID",
+        inputSchema: { campaignId: { type: "string", required: true, description: "Campaign ID" } },
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `
+        query campaign($id: ID!) {
+          campaign(id: $id) {
+            _id name status createdAt provider startAt estimatedEnd
+            schedule { dailyContact dailyLimit minInterval maxInterval trackLinks trackOpens timeZone days start end }
+            recipients { total_count }
+          }
+        }`, { id: input.campaignId });
+            return data.campaign;
+        },
+    });
+    rl.registerAction("campaign.list", {
+        description: "List all campaigns",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = await gql(key(ctx), `
+        query all_campaigns {
+          all_campaigns {
+            _id name status createdAt
+            stats { mailsSent uniqueOpensPercent opens linkClickedPercent repliedPercent bouncedPercent unsubscribePercent progressPercent }
+          }
+        }`);
+            const campaigns = data.all_campaigns;
+            if (limit)
+                return campaigns.slice(0, limit);
+            return campaigns;
+        },
+    });
+    rl.registerAction("campaign.addContact", {
+        description: "Add a contact to a campaign",
+        inputSchema: {
+            campaignId: { type: "string", required: true, description: "Campaign ID" },
+            email: { type: "string", required: true, description: "Contact email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            customFields: { type: "object", required: false, description: "Custom fields as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { campaignId, email, firstName, lastName, customFields } = input;
+            const contact = { email };
+            if (firstName)
+                contact.firstName = firstName;
+            if (lastName)
+                contact.lastName = lastName;
+            if (customFields)
+                Object.assign(contact, customFields);
+            const data = await gql(key(ctx), `
+        mutation AddContactToCampaignHook($id: ID!, $contact: JSON!) {
+          addContactToCampaignHook(id: $id, contact: $contact)
+        }`, { id: campaignId, contact });
+            return { contactId: data.addContactToCampaignHook };
+        },
+    });
+    rl.registerAction("campaign.start", {
+        description: "Start a campaign",
+        inputSchema: { campaignId: { type: "string", required: true, description: "Campaign ID" } },
+        async execute(input, ctx) {
+            await gql(key(ctx), `mutation startCampaign($id: ID!) { startCampaign(id: $id) }`, { id: input.campaignId });
+            return { success: true };
+        },
+    });
+    rl.registerAction("campaign.pause", {
+        description: "Pause a campaign",
+        inputSchema: { campaignId: { type: "string", required: true, description: "Campaign ID" } },
+        async execute(input, ctx) {
+            await gql(key(ctx), `mutation pauseCampaign($id: ID!) { pauseCampaign(id: $id) }`, { id: input.campaignId });
+            return { success: true };
+        },
+    });
+    rl.registerAction("campaign.duplicate", {
+        description: "Duplicate a campaign",
+        inputSchema: {
+            campaignId: { type: "string", required: true, description: "Source campaign ID" },
+            name: { type: "string", required: true, description: "New campaign name" },
+            copySettings: { type: "boolean", required: false, description: "Copy settings (default: true)" },
+            copyMails: { type: "boolean", required: false, description: "Copy mail templates (default: true)" },
+            copyContacts: { type: "boolean", required: false, description: "Copy contacts (default: false)" },
+            copyProvider: { type: "boolean", required: false, description: "Copy provider (default: true)" },
+        },
+        async execute(input, ctx) {
+            const { campaignId, name, copySettings = true, copyMails = true, copyContacts = false, copyProvider = true } = input;
+            const data = await gql(key(ctx), `
+        mutation duplicateCampaign($fromId: ID!, $name: String!, $copySettings: Boolean!, $copyMails: Boolean!, $copyContacts: Boolean!, $copyProvider: Boolean!) {
+          duplicateCampaign(fromId: $fromId, name: $name, copySettings: $copySettings, copyMails: $copyMails, copyContacts: $copyContacts, copyProvider: $copyProvider)
+        }`, { fromId: campaignId, name, copySettings, copyMails, copyContacts, copyProvider });
+            return { _id: data.duplicateCampaign };
+        },
+    });
+    // ── Contact List ────────────────────────────────────
+    rl.registerAction("contactList.list", {
+        description: "List all contact lists",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = await gql(key(ctx), `
+        query contact_lists {
+          contact_lists { _id name contactCount fields usedInCampaign }
+        }`);
+            const lists = data.contact_lists;
+            if (limit)
+                return lists.slice(0, limit);
+            return lists;
+        },
+    });
+    rl.registerAction("contactList.addContact", {
+        description: "Add a contact to a contact list",
+        inputSchema: {
+            contactListId: { type: "string", required: true, description: "Contact list ID" },
+            email: { type: "string", required: true, description: "Contact email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            customFields: { type: "object", required: false, description: "Custom fields as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { contactListId, email, firstName, lastName, customFields } = input;
+            const contact = { email };
+            if (firstName)
+                contact.firstName = firstName;
+            if (lastName)
+                contact.lastName = lastName;
+            if (customFields)
+                Object.assign(contact, customFields);
+            const data = await gql(key(ctx), `
+        mutation AddContactsToListHook($id: ID!, $contact: JSON!) {
+          addContactsToListHook(id: $id, contact: $contact)
+        }`, { id: contactListId, contact });
+            return { contactId: data.addContactsToListHook };
+        },
+    });
+}

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

@@ -0,0 +1,121 @@
+async function apiRequest(host, apiKey, apiSecret, method, endpoint, body, qs) {
+    const url = new URL(`${host}${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: `token ${apiKey}:${apiSecret}`,
+            "Content-Type": "application/json",
+            Accept: "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(`ERPNext API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    return {
+        host: cfg.host.replace(/\/$/, ""),
+        apiKey: cfg.apiKey,
+        apiSecret: cfg.apiSecret,
+    };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { host, apiKey, apiSecret } = getConn(ctx);
+    return apiRequest(host, apiKey, apiSecret, method, endpoint, body, qs);
+}
+export default function erpnext(rl) {
+    rl.setName("erpnext");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "ERPNext instance URL (e.g. https://mysite.erpnext.com)", env: "ERPNEXT_HOST" },
+        apiKey: { type: "string", required: true, description: "API key", env: "ERPNEXT_API_KEY" },
+        apiSecret: { type: "string", required: true, description: "API secret", env: "ERPNEXT_API_SECRET" },
+    });
+    rl.registerAction("document.get", {
+        description: "Get a document by DocType and name",
+        inputSchema: {
+            docType: { type: "string", required: true, description: "Document type (e.g. Customer, Sales Order)" },
+            documentName: { type: "string", required: true, description: "Document name/ID" },
+        },
+        async execute(input, ctx) {
+            const { docType, documentName } = input;
+            const data = (await req(ctx, "GET", `/api/resource/${encodeURIComponent(docType)}/${encodeURIComponent(documentName)}`));
+            return data.data;
+        },
+    });
+    rl.registerAction("document.list", {
+        description: "List documents of a DocType",
+        inputSchema: {
+            docType: { type: "string", required: true, description: "Document type" },
+            fields: { type: "array", required: false, description: "Fields to return (default: ['name']). Use ['*'] for all." },
+            filters: { type: "array", required: false, description: 'Filters as [[doctype, field, operator, value], ...]' },
+            limit: { type: "number", required: false, description: "Max results (default: 20)" },
+            offset: { type: "number", required: false, description: "Start offset" },
+            orderBy: { type: "string", required: false, description: "Order by (e.g. 'creation desc')" },
+        },
+        async execute(input, ctx) {
+            const { docType, fields, filters, limit, offset, orderBy } = (input ?? {});
+            const qs = {};
+            if (fields)
+                qs.fields = JSON.stringify(fields);
+            if (filters)
+                qs.filters = JSON.stringify(filters);
+            if (limit)
+                qs.limit_page_length = limit;
+            if (offset)
+                qs.limit_start = offset;
+            if (orderBy)
+                qs.order_by = orderBy;
+            const data = (await req(ctx, "GET", `/api/resource/${encodeURIComponent(docType)}`, undefined, qs));
+            return data.data;
+        },
+    });
+    rl.registerAction("document.create", {
+        description: "Create a document",
+        inputSchema: {
+            docType: { type: "string", required: true, description: "Document type" },
+            properties: { type: "object", required: true, description: "Document field values as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { docType, properties } = input;
+            const data = (await req(ctx, "POST", `/api/resource/${encodeURIComponent(docType)}`, properties));
+            return data.data;
+        },
+    });
+    rl.registerAction("document.update", {
+        description: "Update a document",
+        inputSchema: {
+            docType: { type: "string", required: true, description: "Document type" },
+            documentName: { type: "string", required: true, description: "Document name/ID" },
+            properties: { type: "object", required: true, description: "Fields to update as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const { docType, documentName, properties } = input;
+            const data = (await req(ctx, "PUT", `/api/resource/${encodeURIComponent(docType)}/${encodeURIComponent(documentName)}`, properties));
+            return data.data;
+        },
+    });
+    rl.registerAction("document.delete", {
+        description: "Delete a document",
+        inputSchema: {
+            docType: { type: "string", required: true, description: "Document type" },
+            documentName: { type: "string", required: true, description: "Document name/ID" },
+        },
+        async execute(input, ctx) {
+            const { docType, documentName } = input;
+            await req(ctx, "DELETE", `/api/resource/${encodeURIComponent(docType)}/${encodeURIComponent(documentName)}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,57 @@
+export default function facebookGraph(rl) {
+    rl.setName("facebookGraph");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Facebook/Meta access token", env: "FACEBOOK_ACCESS_TOKEN" },
+    });
+    rl.registerAction("request", {
+        description: "Make a request to the Facebook Graph API. Supports GET, POST, DELETE against any node/edge combination.",
+        inputSchema: {
+            hostUrl: { type: "string", required: false, description: "Host URL: 'graph.facebook.com' (default) or 'graph-video.facebook.com' for video uploads" },
+            method: { type: "string", required: false, description: "HTTP method: GET (default), POST, DELETE" },
+            graphApiVersion: { type: "string", required: false, description: "API version (e.g. 'v19.0'). Omit for default." },
+            node: { type: "string", required: true, description: "Node ID (e.g. 'me', a page/user/object ID)" },
+            edge: { type: "string", required: false, description: "Edge name (e.g. 'posts', 'feed', 'videos')" },
+            fields: { type: "array", required: false, description: "Fields to request (GET only), sent as comma-separated 'fields' param" },
+            queryParameters: { type: "object", required: false, description: "Additional query parameters as key-value pairs" },
+            body: { type: "object", required: false, description: "Request body for POST requests (sent as JSON)" },
+        },
+        async execute(input, ctx) {
+            const { hostUrl = "graph.facebook.com", method = "GET", graphApiVersion = "", node, edge, fields, queryParameters, body, } = input;
+            const versionPrefix = graphApiVersion ? `${graphApiVersion}/` : "";
+            let uri = `https://${hostUrl}/${versionPrefix}${node}`;
+            if (edge)
+                uri = `${uri}/${edge}`;
+            const url = new URL(uri);
+            url.searchParams.set("access_token", ctx.connection.config.accessToken);
+            if (fields && Array.isArray(fields) && fields.length > 0) {
+                url.searchParams.set("fields", fields.join(","));
+            }
+            if (queryParameters && typeof queryParameters === "object") {
+                for (const [k, v] of Object.entries(queryParameters)) {
+                    if (v !== undefined && v !== null)
+                        url.searchParams.set(k, String(v));
+                }
+            }
+            const httpMethod = method.toUpperCase();
+            const opts = {
+                method: httpMethod,
+                headers: { Accept: "application/json,text/*;q=0.99" },
+            };
+            if (body && typeof body === "object" && Object.keys(body).length > 0 && httpMethod === "POST") {
+                opts.headers["Content-Type"] = "application/json";
+                opts.body = JSON.stringify(body);
+            }
+            const res = await fetch(url.toString(), opts);
+            if (!res.ok)
+                throw new Error(`Facebook Graph API error ${res.status}: ${await res.text()}`);
+            const text = await res.text();
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return { message: text };
+            }
+        },
+    });
+}

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

@@ -0,0 +1,320 @@
+const STATUS = { open: 2, pending: 3, resolved: 4, closed: 5 };
+const PRIORITY = { low: 1, medium: 2, high: 3, urgent: 4 };
+const SOURCE = { email: 1, portal: 2, phone: 3, chat: 7, mobihelp: 8, feedbackWidget: 9, outboundEmail: 10 };
+async function apiRequest(domain, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`https://${domain}.freshdesk.com/api/v2${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}:X`)}`,
+            "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(`Freshdesk API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        domain: ctx.connection.config.domain,
+        apiKey: ctx.connection.config.apiKey,
+    };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { domain, apiKey } = getConn(ctx);
+    return apiRequest(domain, apiKey, method, endpoint, body, qs);
+}
+export default function freshdesk(rl) {
+    rl.setName("freshdesk");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        domain: { type: "string", required: true, description: "Freshdesk subdomain (e.g. 'mycompany' for mycompany.freshdesk.com)", env: "FRESHDESK_DOMAIN" },
+        apiKey: { type: "string", required: true, description: "Freshdesk API key", env: "FRESHDESK_API_KEY" },
+    });
+    // ── Ticket ──────────────────────────────────────────
+    rl.registerAction("ticket.create", {
+        description: "Create a ticket",
+        inputSchema: {
+            email: { type: "string", required: false, description: "Requester email" },
+            requesterId: { type: "number", required: false, description: "Requester user ID" },
+            phone: { type: "string", required: false, description: "Requester phone" },
+            subject: { type: "string", required: false, description: "Ticket subject" },
+            description: { type: "string", required: false, description: "Ticket description (HTML)" },
+            status: { type: "string", required: true, description: "open, pending, resolved, closed" },
+            priority: { type: "string", required: true, description: "low, medium, high, urgent" },
+            source: { type: "string", required: false, description: "email, portal, phone, chat, feedbackWidget, mobihelp, outboundEmail" },
+            type: { type: "string", required: false, description: "Question, Incident, Problem, Feature Request, Refund" },
+            responderId: { type: "number", required: false, description: "Agent ID" },
+            groupId: { type: "number", required: false, description: "Group ID" },
+            productId: { type: "number", required: false, description: "Product ID" },
+            companyId: { type: "number", required: false, description: "Company ID" },
+            tags: { type: "array", required: false, description: "Tags" },
+            ccEmails: { type: "array", required: false, description: "CC email addresses" },
+            dueBy: { type: "string", required: false, description: "Due date (ISO 8601)" },
+            frDueBy: { type: "string", required: false, description: "First response due date" },
+            customFields: { type: "object", required: false, description: "Custom fields as key-value pairs" },
+        },
+        async execute(input, ctx) {
+            const i = input;
+            const body = {
+                status: STATUS[i.status] ?? 3,
+                priority: PRIORITY[i.priority] ?? 1,
+            };
+            if (i.email)
+                body.email = i.email;
+            if (i.requesterId)
+                body.requester_id = i.requesterId;
+            if (i.phone)
+                body.phone = i.phone;
+            if (i.subject)
+                body.subject = i.subject;
+            if (i.description)
+                body.description = i.description;
+            if (i.source)
+                body.source = SOURCE[i.source] ?? 2;
+            if (i.type)
+                body.type = i.type;
+            if (i.responderId)
+                body.responder_id = i.responderId;
+            if (i.groupId)
+                body.group_id = i.groupId;
+            if (i.productId)
+                body.product_id = i.productId;
+            if (i.companyId)
+                body.company_id = i.companyId;
+            if (i.tags)
+                body.tags = i.tags;
+            if (i.ccEmails)
+                body.cc_emails = i.ccEmails;
+            if (i.dueBy)
+                body.due_by = i.dueBy;
+            if (i.frDueBy)
+                body.fr_due_by = i.frDueBy;
+            if (i.customFields)
+                body.custom_fields = i.customFields;
+            return req(ctx, "POST", "/tickets", body);
+        },
+    });
+    rl.registerAction("ticket.get", {
+        description: "Get a ticket by ID",
+        inputSchema: { ticketId: { type: "string", required: true, description: "Ticket ID" } },
+        async execute(input, ctx) {
+            return req(ctx, "GET", `/tickets/${input.ticketId}`);
+        },
+    });
+    rl.registerAction("ticket.list", {
+        description: "List tickets",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results (default: 30)" },
+            requesterId: { type: "string", required: false, description: "Filter by requester ID" },
+            requesterEmail: { type: "string", required: false, description: "Filter by requester email" },
+            companyId: { type: "string", required: false, description: "Filter by company ID" },
+            updatedSince: { type: "string", required: false, description: "Filter by updated since (ISO 8601)" },
+            orderBy: { type: "string", required: false, description: "created_at, due_by, updated_at" },
+            orderType: { type: "string", required: false, description: "asc or desc" },
+            include: { type: "string", required: false, description: "Comma-separated: requester, company, stats, description" },
+        },
+        async execute(input, ctx) {
+            const { limit, requesterId, requesterEmail, companyId, updatedSince, orderBy, orderType, include } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (requesterId)
+                qs.requester_id = requesterId;
+            if (requesterEmail)
+                qs.email = requesterEmail;
+            if (companyId)
+                qs.company_id = companyId;
+            if (updatedSince)
+                qs.updated_since = updatedSince;
+            if (orderBy)
+                qs.order_by = orderBy;
+            if (orderType)
+                qs.order_type = orderType;
+            if (include)
+                qs.include = include;
+            return req(ctx, "GET", "/tickets", undefined, qs);
+        },
+    });
+    rl.registerAction("ticket.update", {
+        description: "Update a ticket",
+        inputSchema: {
+            ticketId: { type: "string", required: true, description: "Ticket ID" },
+            status: { type: "string", required: false, description: "open, pending, resolved, closed" },
+            priority: { type: "string", required: false, description: "low, medium, high, urgent" },
+            source: { type: "string", required: false, description: "Source" },
+            type: { type: "string", required: false, description: "Ticket type" },
+            responderId: { type: "number", required: false, description: "Agent ID" },
+            groupId: { type: "number", required: false, description: "Group ID" },
+            productId: { type: "number", required: false, description: "Product ID" },
+            companyId: { type: "number", required: false, description: "Company ID" },
+            tags: { type: "array", required: false, description: "Tags" },
+            dueBy: { type: "string", required: false, description: "Due date" },
+            frDueBy: { type: "string", required: false, description: "First response due" },
+            customFields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { ticketId, status, priority, source, type, responderId, groupId, productId, companyId, tags, dueBy, frDueBy, customFields } = input;
+            const body = {};
+            if (status)
+                body.status = STATUS[status];
+            if (priority)
+                body.priority = PRIORITY[priority];
+            if (source)
+                body.source = SOURCE[source];
+            if (type)
+                body.type = type;
+            if (responderId)
+                body.responder_id = responderId;
+            if (groupId)
+                body.group_id = groupId;
+            if (productId)
+                body.product_id = productId;
+            if (companyId)
+                body.company_id = companyId;
+            if (tags)
+                body.tags = tags;
+            if (dueBy)
+                body.due_by = dueBy;
+            if (frDueBy)
+                body.fr_due_by = frDueBy;
+            if (customFields)
+                body.custom_fields = customFields;
+            return req(ctx, "PUT", `/tickets/${ticketId}`, body);
+        },
+    });
+    rl.registerAction("ticket.delete", {
+        description: "Delete a ticket",
+        inputSchema: { ticketId: { type: "string", required: true, description: "Ticket ID" } },
+        async execute(input, ctx) {
+            await req(ctx, "DELETE", `/tickets/${input.ticketId}`);
+            return { success: true };
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Full name" },
+            email: { type: "string", required: false, description: "Email address" },
+            phone: { type: "string", required: false, description: "Phone number" },
+            mobile: { type: "string", required: false, description: "Mobile number" },
+            address: { type: "string", required: false, description: "Address" },
+            description: { type: "string", required: false, description: "Description" },
+            jobTitle: { type: "string", required: false, description: "Job title" },
+            tags: { type: "array", required: false, description: "Tags" },
+            companyId: { type: "number", required: false, description: "Company ID" },
+            customFields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { name, email, phone, mobile, address, description: desc, jobTitle, tags, companyId, customFields } = input;
+            const body = { name };
+            if (email)
+                body.email = email;
+            if (phone)
+                body.phone = phone;
+            if (mobile)
+                body.mobile = mobile;
+            if (address)
+                body.address = address;
+            if (desc)
+                body.description = desc;
+            if (jobTitle)
+                body.job_title = jobTitle;
+            if (tags)
+                body.tags = tags;
+            if (companyId)
+                body.company_id = companyId;
+            if (customFields)
+                body.custom_fields = customFields;
+            return req(ctx, "POST", "/contacts", body);
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) {
+            return req(ctx, "GET", `/contacts/${input.contactId}`);
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts",
+        inputSchema: {
+            email: { type: "string", required: false, description: "Filter by email" },
+            phone: { type: "string", required: false, description: "Filter by phone" },
+            mobile: { type: "string", required: false, description: "Filter by mobile" },
+            companyId: { type: "string", required: false, description: "Filter by company ID" },
+            state: { type: "string", required: false, description: "verified, unverified, blocked, deleted" },
+        },
+        async execute(input, ctx) {
+            const { email, phone, mobile, companyId, state } = (input ?? {});
+            const qs = {};
+            if (email)
+                qs.email = email;
+            if (phone)
+                qs.phone = phone;
+            if (mobile)
+                qs.mobile = mobile;
+            if (companyId)
+                qs.company_id = companyId;
+            if (state)
+                qs.state = state;
+            return req(ctx, "GET", "/contacts", undefined, qs);
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            name: { type: "string", required: false, description: "Name" },
+            email: { type: "string", required: false, description: "Email" },
+            phone: { type: "string", required: false, description: "Phone" },
+            mobile: { type: "string", required: false, description: "Mobile" },
+            address: { type: "string", required: false, description: "Address" },
+            jobTitle: { type: "string", required: false, description: "Job title" },
+            tags: { type: "array", required: false, description: "Tags" },
+            customFields: { type: "object", required: false, description: "Custom fields" },
+        },
+        async execute(input, ctx) {
+            const { contactId, name, email, phone, mobile, address, jobTitle, tags, customFields } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (email)
+                body.email = email;
+            if (phone)
+                body.phone = phone;
+            if (mobile)
+                body.mobile = mobile;
+            if (address)
+                body.address = address;
+            if (jobTitle)
+                body.job_title = jobTitle;
+            if (tags)
+                body.tags = tags;
+            if (customFields)
+                body.custom_fields = customFields;
+            return req(ctx, "PUT", `/contacts/${contactId}`, body);
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) {
+            await req(ctx, "DELETE", `/contacts/${input.contactId}`);
+            return { success: true };
+        },
+    });
+}