runline 0.1.0

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

@@ -0,0 +1,172 @@
+const BASE = "https://services.leadconnectorhq.com";
+function getConn(ctx) {
+    return {
+        token: ctx.connection.config.accessToken,
+        locationId: ctx.connection.config.locationId,
+    };
+}
+async function api(token, method, path, body, qs) {
+    const url = new URL(`${BASE}${path}`);
+    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 ${token}`, "Content-Type": "application/json", Accept: "application/json", Version: "2021-07-28" } };
+    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(`HighLevel error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+export default function highlevel(rl) {
+    rl.setName("highlevel");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "OAuth2 access token", env: "HIGHLEVEL_ACCESS_TOKEN" },
+        locationId: { type: "string", required: true, description: "Location ID", env: "HIGHLEVEL_LOCATION_ID" },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.upsert", { description: "Create or update a contact (upsert by email/phone)",
+        inputSchema: { email: { type: "string", required: false }, phone: { type: "string", required: false }, firstName: { type: "string", required: false }, lastName: { type: "string", required: false }, name: { type: "string", required: false }, address1: { type: "string", required: false }, city: { type: "string", required: false }, state: { type: "string", required: false }, postalCode: { type: "string", required: false }, website: { type: "string", required: false }, tags: { type: "object", required: false, description: "Array of tag strings" }, timezone: { type: "string", required: false }, dnd: { type: "boolean", required: false }, source: { type: "string", required: false }, customFields: { type: "object", required: false, description: "Array of {id, field_value}" } },
+        async execute(input, ctx) {
+            const { token, locationId } = getConn(ctx);
+            const body = { ...input, locationId };
+            if (typeof body.tags === "string")
+                body.tags = body.tags.split(",").map((t) => t.trim());
+            const res = await api(token, "POST", "/contacts/upsert/", body);
+            return res.contact ?? res;
+        } });
+    rl.registerAction("contact.get", { description: "Get a contact by ID", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); const res = await api(token, "GET", `/contacts/${input.id}/`); return res.contact ?? res; } });
+    rl.registerAction("contact.list", { description: "List contacts",
+        inputSchema: { limit: { type: "number", required: false }, query: { type: "string", required: false, description: "Search by name, phone, email, tags, company" }, sortBy: { type: "string", required: false, description: "date_added or date_updated" }, order: { type: "string", required: false, description: "asc or desc" } },
+        async execute(input, ctx) {
+            const { token, locationId } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = { locationId };
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.query)
+                qs.query = p.query;
+            if (p.sortBy)
+                qs.sortBy = p.sortBy;
+            if (p.order)
+                qs.order = p.order;
+            const res = await api(token, "GET", "/contacts/", undefined, qs);
+            return res.contacts ?? res;
+        } });
+    rl.registerAction("contact.update", { description: "Update a contact",
+        inputSchema: { id: { type: "string", required: true }, email: { type: "string", required: false }, phone: { type: "string", required: false }, firstName: { type: "string", required: false }, lastName: { type: "string", required: false }, name: { type: "string", required: false }, address1: { type: "string", required: false }, city: { type: "string", required: false }, state: { type: "string", required: false }, postalCode: { type: "string", required: false }, website: { type: "string", required: false }, tags: { type: "object", required: false }, timezone: { type: "string", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const { id, ...body } = input;
+            if (typeof body.tags === "string")
+                body.tags = body.tags.split(",").map((t) => t.trim());
+            const res = await api(token, "PUT", `/contacts/${id}/`, body);
+            return res.contact ?? res;
+        } });
+    rl.registerAction("contact.delete", { description: "Delete a contact", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); await api(token, "DELETE", `/contacts/${input.id}/`); return { success: true }; } });
+    // ── Opportunity ─────────────────────────────────────
+    rl.registerAction("opportunity.create", { description: "Create an opportunity",
+        inputSchema: { contactId: { type: "string", required: true }, name: { type: "string", required: true }, status: { type: "string", required: true, description: "open, won, lost, or abandoned" }, pipelineId: { type: "string", required: true }, stageId: { type: "string", required: false, description: "Pipeline stage ID" }, monetaryValue: { type: "number", required: false }, assignedTo: { type: "string", required: false }, companyName: { type: "string", required: false }, tags: { type: "object", required: false } },
+        async execute(input, ctx) {
+            const { token, locationId } = getConn(ctx);
+            const body = { ...input, locationId };
+            if (body.stageId) {
+                body.pipelineStageId = body.stageId;
+                delete body.stageId;
+            }
+            if (typeof body.tags === "string")
+                body.tags = body.tags.split(",").map((t) => t.trim());
+            return api(token, "POST", "/opportunities/", body);
+        } });
+    rl.registerAction("opportunity.get", { description: "Get an opportunity", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); return api(token, "GET", `/opportunities/${input.id}`); } });
+    rl.registerAction("opportunity.list", { description: "List opportunities",
+        inputSchema: { limit: { type: "number", required: false }, pipelineId: { type: "string", required: false }, stageId: { type: "string", required: false }, status: { type: "string", required: false }, assignedTo: { type: "string", required: false }, query: { type: "string", required: false }, startDate: { type: "string", required: false }, endDate: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { token, locationId } = getConn(ctx);
+            const p = (input ?? {});
+            const qs = { location_id: locationId };
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.pipelineId)
+                qs.pipeline_id = p.pipelineId;
+            if (p.stageId)
+                qs.pipeline_stage_id = p.stageId;
+            if (p.status)
+                qs.status = p.status;
+            if (p.assignedTo)
+                qs.assigned_to = p.assignedTo;
+            if (p.query)
+                qs.q = p.query;
+            if (p.startDate)
+                qs.startDate = new Date(p.startDate).getTime();
+            if (p.endDate)
+                qs.endDate = new Date(p.endDate).getTime();
+            const res = await api(token, "GET", "/opportunities/search", undefined, qs);
+            return res.opportunities ?? res;
+        } });
+    rl.registerAction("opportunity.update", { description: "Update an opportunity",
+        inputSchema: { id: { type: "string", required: true }, name: { type: "string", required: false }, status: { type: "string", required: false }, pipelineId: { type: "string", required: false }, stageId: { type: "string", required: false }, monetaryValue: { type: "number", required: false }, assignedTo: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const { id, ...body } = input;
+            if (body.stageId) {
+                body.pipelineStageId = body.stageId;
+                delete body.stageId;
+            }
+            return api(token, "PUT", `/opportunities/${id}`, body);
+        } });
+    rl.registerAction("opportunity.delete", { description: "Delete an opportunity", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); await api(token, "DELETE", `/opportunities/${input.id}`); return { success: true }; } });
+    // ── Task (scoped to contact) ────────────────────────
+    rl.registerAction("task.create", { description: "Create a task for a contact",
+        inputSchema: { contactId: { type: "string", required: true }, title: { type: "string", required: true }, dueDate: { type: "string", required: true, description: "ISO datetime" }, completed: { type: "boolean", required: false }, body: { type: "string", required: false }, assignedTo: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const { contactId, ...body } = input;
+            return api(token, "POST", `/contacts/${contactId}/tasks/`, body);
+        } });
+    rl.registerAction("task.get", { description: "Get a task",
+        inputSchema: { contactId: { type: "string", required: true }, taskId: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); const p = input; return api(token, "GET", `/contacts/${p.contactId}/tasks/${p.taskId}/`); } });
+    rl.registerAction("task.list", { description: "List tasks for a contact",
+        inputSchema: { contactId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const res = await api(token, "GET", `/contacts/${input.contactId}/tasks/`);
+            return res.tasks ?? res;
+        } });
+    rl.registerAction("task.update", { description: "Update a task",
+        inputSchema: { contactId: { type: "string", required: true }, taskId: { type: "string", required: true }, title: { type: "string", required: false }, dueDate: { type: "string", required: false }, completed: { type: "boolean", required: false }, body: { type: "string", required: false }, assignedTo: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const { contactId, taskId, ...body } = input;
+            return api(token, "PUT", `/contacts/${contactId}/tasks/${taskId}/`, body);
+        } });
+    rl.registerAction("task.delete", { description: "Delete a task",
+        inputSchema: { contactId: { type: "string", required: true }, taskId: { type: "string", required: true } },
+        async execute(input, ctx) { const { token } = getConn(ctx); const p = input; await api(token, "DELETE", `/contacts/${p.contactId}/tasks/${p.taskId}/`); return { success: true }; } });
+    // ── Calendar ────────────────────────────────────────
+    rl.registerAction("calendar.bookAppointment", { description: "Book a calendar appointment",
+        inputSchema: { calendarId: { type: "string", required: true }, locationId: { type: "string", required: true }, contactId: { type: "string", required: true }, startTime: { type: "string", required: true, description: "ISO datetime with timezone offset" }, endTime: { type: "string", required: false }, title: { type: "string", required: false }, appointmentStatus: { type: "string", required: false, description: "new, confirmed, cancelled, showed, noshow, invalid" }, assignedUserId: { type: "string", required: false }, address: { type: "string", required: false }, toNotify: { type: "boolean", required: false } },
+        async execute(input, ctx) { const { token } = getConn(ctx); return api(token, "POST", "/calendars/events/appointments", input); } });
+    rl.registerAction("calendar.getFreeSlots", { description: "Get free slots for a calendar",
+        inputSchema: { calendarId: { type: "string", required: true }, startDate: { type: "number", required: true, description: "Start date as epoch ms" }, endDate: { type: "number", required: true, description: "End date as epoch ms" }, timezone: { type: "string", required: false }, userId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { token } = getConn(ctx);
+            const p = input;
+            const qs = { startDate: p.startDate, endDate: p.endDate };
+            if (p.timezone)
+                qs.timezone = p.timezone;
+            if (p.userId)
+                qs.userId = p.userId;
+            return api(token, "GET", `/calendars/${p.calendarId}/free-slots`, undefined, qs);
+        } });
+}

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

@@ -0,0 +1,148 @@
+async function apiRequest(baseUrl, token, 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: `Bearer ${token}`, "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(`Home Assistant API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    const ssl = cfg.ssl === true || cfg.ssl === "true";
+    const proto = ssl ? "https" : "http";
+    return { baseUrl: `${proto}://${cfg.host}:${cfg.port ?? 8123}`, token: cfg.accessToken };
+}
+function ha(ctx, method, endpoint, body, qs) {
+    const { baseUrl, token } = getConn(ctx);
+    return apiRequest(baseUrl, token, method, endpoint, body, qs);
+}
+export default function homeAssistant(rl) {
+    rl.setName("homeAssistant");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "Home Assistant host (e.g. 192.168.1.100)", env: "HASS_HOST" },
+        port: { type: "number", required: false, description: "Port (default: 8123)", default: "8123" },
+        ssl: { type: "boolean", required: false, description: "Use HTTPS", default: "false" },
+        accessToken: { type: "string", required: true, description: "Long-lived access token", env: "HASS_TOKEN" },
+    });
+    rl.registerAction("config.get", {
+        description: "Get Home Assistant configuration",
+        async execute(_input, ctx) { return ha(ctx, "GET", "/config"); },
+    });
+    rl.registerAction("config.check", {
+        description: "Check if configuration is valid",
+        async execute(_input, ctx) { return ha(ctx, "POST", "/config/core/check_config"); },
+    });
+    rl.registerAction("service.list", {
+        description: "List available services",
+        async execute(_input, ctx) { return ha(ctx, "GET", "/services"); },
+    });
+    rl.registerAction("service.call", {
+        description: "Call a service",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Service domain (e.g. light, switch)" },
+            service: { type: "string", required: true, description: "Service name (e.g. turn_on)" },
+            serviceData: { type: "object", required: false, description: "Service data (e.g. {entity_id: 'light.kitchen'})" },
+        },
+        async execute(input, ctx) {
+            const { domain, service, serviceData } = input;
+            return ha(ctx, "POST", `/services/${domain}/${service}`, serviceData ?? {});
+        },
+    });
+    rl.registerAction("state.list", {
+        description: "List all entity states",
+        async execute(_input, ctx) { return ha(ctx, "GET", "/states"); },
+    });
+    rl.registerAction("state.get", {
+        description: "Get state of an entity",
+        inputSchema: { entityId: { type: "string", required: true, description: "Entity ID (e.g. light.kitchen)" } },
+        async execute(input, ctx) { return ha(ctx, "GET", `/states/${input.entityId}`); },
+    });
+    rl.registerAction("state.set", {
+        description: "Set/update state of an entity",
+        inputSchema: {
+            entityId: { type: "string", required: true, description: "Entity ID" },
+            state: { type: "string", required: true, description: "New state value" },
+            attributes: { type: "object", required: false, description: "State attributes" },
+        },
+        async execute(input, ctx) {
+            const { entityId, state, attributes } = input;
+            const body = { state };
+            if (attributes)
+                body.attributes = attributes;
+            return ha(ctx, "POST", `/states/${entityId}`, body);
+        },
+    });
+    rl.registerAction("event.list", {
+        description: "List event types",
+        async execute(_input, ctx) { return ha(ctx, "GET", "/events"); },
+    });
+    rl.registerAction("event.fire", {
+        description: "Fire an event",
+        inputSchema: {
+            eventType: { type: "string", required: true, description: "Event type" },
+            eventData: { type: "object", required: false, description: "Event data" },
+        },
+        async execute(input, ctx) {
+            const { eventType, eventData } = input;
+            return ha(ctx, "POST", `/events/${eventType}`, eventData ?? {});
+        },
+    });
+    rl.registerAction("log.getErrors", {
+        description: "Get error log",
+        async execute(_input, ctx) { return ha(ctx, "GET", "/error_log"); },
+    });
+    rl.registerAction("log.getLogbook", {
+        description: "Get logbook entries",
+        inputSchema: {
+            entityId: { type: "string", required: false, description: "Filter by entity ID" },
+            startTime: { type: "string", required: false, description: "Start time (ISO 8601)" },
+            endTime: { type: "string", required: false, description: "End time (ISO 8601)" },
+        },
+        async execute(input, ctx) {
+            const { entityId, startTime, endTime } = (input ?? {});
+            let endpoint = "/logbook";
+            if (startTime)
+                endpoint += `/${startTime}`;
+            const qs = {};
+            if (entityId)
+                qs.entity = entityId;
+            if (endTime)
+                qs.end_time = endTime;
+            return ha(ctx, "GET", endpoint, undefined, qs);
+        },
+    });
+    rl.registerAction("template.render", {
+        description: "Render a Jinja2 template",
+        inputSchema: { template: { type: "string", required: true, description: "Jinja2 template string" } },
+        async execute(input, ctx) { return ha(ctx, "POST", "/template", { template: input.template }); },
+    });
+    rl.registerAction("history.get", {
+        description: "Get state history for entities",
+        inputSchema: {
+            entityIds: { type: "string", required: false, description: "Comma-separated entity IDs" },
+            startTime: { type: "string", required: false, description: "Start time (ISO 8601)" },
+            endTime: { type: "string", required: false, description: "End time" },
+        },
+        async execute(input, ctx) {
+            const { entityIds, startTime, endTime } = (input ?? {});
+            let endpoint = "/history/period";
+            if (startTime)
+                endpoint += `/${startTime}`;
+            const qs = {};
+            if (entityIds)
+                qs.filter_entity_id = entityIds;
+            if (endTime)
+                qs.end_time = endTime;
+            return ha(ctx, "GET", endpoint, undefined, qs);
+        },
+    });
+}

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

@@ -0,0 +1,176 @@
+const BASE_URL = "https://api.hubapi.com";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = { method, headers: { Authorization: `Bearer ${token}`, "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(`HubSpot API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function hubspot(rl) {
+    rl.setName("hubspot");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "HubSpot private app access token", env: "HUBSPOT_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    // Helper for CRM objects (contacts, companies, deals, tickets)
+    function registerCrmObject(resource, objectType) {
+        rl.registerAction(`${resource}.create`, {
+            description: `Create a ${resource}`, inputSchema: { properties: { type: "object", required: true, description: "Properties as key-value pairs" } },
+            async execute(input, ctx) { return apiRequest(tok(ctx), "POST", `/crm/v3/objects/${objectType}`, { properties: input.properties }); },
+        });
+        rl.registerAction(`${resource}.get`, {
+            description: `Get a ${resource}`, inputSchema: { id: { type: "string", required: true, description: `${resource} ID` }, properties: { type: "array", required: false, description: "Properties to return" } },
+            async execute(input, ctx) {
+                const { id, properties } = input;
+                const qs = {};
+                if (properties && Array.isArray(properties))
+                    qs.properties = properties.join(",");
+                return apiRequest(tok(ctx), "GET", `/crm/v3/objects/${objectType}/${id}`, undefined, qs);
+            },
+        });
+        rl.registerAction(`${resource}.list`, {
+            description: `List ${resource}s`, inputSchema: { limit: { type: "number", required: false, description: "Max results (max 100)" }, after: { type: "string", required: false, description: "Pagination cursor" }, properties: { type: "array", required: false, description: "Properties to return" } },
+            async execute(input, ctx) {
+                const { limit, after, properties } = (input ?? {});
+                const qs = {};
+                if (limit)
+                    qs.limit = limit;
+                if (after)
+                    qs.after = after;
+                if (properties && Array.isArray(properties))
+                    qs.properties = properties.join(",");
+                return apiRequest(tok(ctx), "GET", `/crm/v3/objects/${objectType}`, undefined, qs);
+            },
+        });
+        rl.registerAction(`${resource}.update`, {
+            description: `Update a ${resource}`, inputSchema: { id: { type: "string", required: true, description: `${resource} ID` }, properties: { type: "object", required: true, description: "Properties to update" } },
+            async execute(input, ctx) { const { id, properties } = input; return apiRequest(tok(ctx), "PATCH", `/crm/v3/objects/${objectType}/${id}`, { properties }); },
+        });
+        rl.registerAction(`${resource}.delete`, {
+            description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true, description: `${resource} ID` } },
+            async execute(input, ctx) { await apiRequest(tok(ctx), "DELETE", `/crm/v3/objects/${objectType}/${input.id}`); return { success: true }; },
+        });
+        rl.registerAction(`${resource}.search`, {
+            description: `Search ${resource}s`,
+            inputSchema: {
+                filterGroups: { type: "array", required: true, description: "Filter groups [{filters: [{propertyName, operator, value}]}]" },
+                properties: { type: "array", required: false, description: "Properties to return" },
+                limit: { type: "number", required: false, description: "Max results" },
+                after: { type: "string", required: false, description: "Pagination" },
+            },
+            async execute(input, ctx) {
+                const { filterGroups, properties, limit, after } = input;
+                const body = { filterGroups };
+                if (properties)
+                    body.properties = properties;
+                if (limit)
+                    body.limit = limit;
+                if (after)
+                    body.after = after;
+                return apiRequest(tok(ctx), "POST", `/crm/v3/objects/${objectType}/search`, body);
+            },
+        });
+    }
+    registerCrmObject("contact", "contacts");
+    registerCrmObject("company", "companies");
+    registerCrmObject("deal", "deals");
+    registerCrmObject("ticket", "tickets");
+    // ── Contact List ────────────────────────────────────
+    rl.registerAction("contactList.addContacts", {
+        description: "Add contacts to a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactIds: { type: "array", required: true, description: "Array of contact IDs" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactIds } = input;
+            return apiRequest(tok(ctx), "POST", `/contacts/v1/lists/${listId}/add`, { vids: contactIds });
+        },
+    });
+    rl.registerAction("contactList.removeContacts", {
+        description: "Remove contacts from a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactIds: { type: "array", required: true, description: "Array of contact IDs" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactIds } = input;
+            return apiRequest(tok(ctx), "POST", `/contacts/v1/lists/${listId}/remove`, { vids: contactIds });
+        },
+    });
+    // ── Engagement ──────────────────────────────────────
+    rl.registerAction("engagement.create", {
+        description: "Create an engagement (note, email, task, meeting, call)",
+        inputSchema: {
+            type: { type: "string", required: true, description: "NOTE, EMAIL, TASK, MEETING, CALL" },
+            properties: { type: "object", required: true, description: "Engagement metadata" },
+            associations: { type: "object", required: false, description: "{contactIds, companyIds, dealIds, ticketIds}" },
+        },
+        async execute(input, ctx) {
+            const { type, properties, associations } = input;
+            const body = {
+                engagement: { type, ...properties },
+            };
+            if (associations)
+                body.associations = associations;
+            return apiRequest(tok(ctx), "POST", "/engagements/v1/engagements", body);
+        },
+    });
+    rl.registerAction("engagement.get", {
+        description: "Get an engagement",
+        inputSchema: { engagementId: { type: "string", required: true, description: "Engagement ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/engagements/v1/engagements/${input.engagementId}`); },
+    });
+    rl.registerAction("engagement.list", {
+        description: "List engagements",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" }, offset: { type: "number", required: false, description: "Offset" } },
+        async execute(input, ctx) {
+            const { limit, offset } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (offset)
+                qs.offset = offset;
+            return apiRequest(tok(ctx), "GET", "/engagements/v1/engagements/paged", undefined, qs);
+        },
+    });
+    rl.registerAction("engagement.delete", {
+        description: "Delete an engagement",
+        inputSchema: { engagementId: { type: "string", required: true, description: "Engagement ID" } },
+        async execute(input, ctx) { await apiRequest(tok(ctx), "DELETE", `/engagements/v1/engagements/${input.engagementId}`); return { success: true }; },
+    });
+    // ── Form ────────────────────────────────────────────
+    rl.registerAction("form.submit", {
+        description: "Submit a HubSpot form",
+        inputSchema: {
+            portalId: { type: "string", required: true, description: "Portal (Hub) ID" },
+            formId: { type: "string", required: true, description: "Form GUID" },
+            fields: { type: "array", required: true, description: "Array of {name, value} objects" },
+            context: { type: "object", required: false, description: "Submission context (hutk, pageUri, pageName)" },
+        },
+        async execute(input, ctx) {
+            const { portalId, formId, fields, context } = input;
+            const body = { fields };
+            if (context)
+                body.context = context;
+            return apiRequest(tok(ctx), "POST", `/submissions/v3/integration/secure/submit/${portalId}/${formId}`, body);
+        },
+    });
+    rl.registerAction("form.getFields", {
+        description: "Get form fields",
+        inputSchema: { formId: { type: "string", required: true, description: "Form GUID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/forms/v2/fields/${input.formId}`); },
+    });
+}

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

@@ -0,0 +1,60 @@
+const BASE_URL = "https://api.humantic.ai/v1";
+async function apiRequest(apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    url.searchParams.set("apikey", apiKey);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = { method, headers: { "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0 && method !== "GET")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Humantic AI error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function humanticAi(rl) {
+    rl.setName("humanticAi");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Humantic AI API key", env: "HUMANTIC_AI_API_KEY" } });
+    rl.registerAction("profile.create", {
+        description: "Create a user profile from LinkedIn URL or text",
+        inputSchema: { userId: { type: "string", required: true, description: "Unique user identifier" }, linkedinUrl: { type: "string", required: false, description: "LinkedIn profile URL" }, text: { type: "string", required: false, description: "Text content to analyze" } },
+        async execute(input, ctx) {
+            const { userId, linkedinUrl, text } = input;
+            const body = { userid: userId };
+            if (linkedinUrl)
+                body.linkedin_url = linkedinUrl;
+            if (text)
+                body.text = text;
+            return apiRequest(ctx.connection.config.apiKey, "POST", "/user-profile/create", body);
+        },
+    });
+    rl.registerAction("profile.get", {
+        description: "Get a user profile/personality analysis",
+        inputSchema: { userId: { type: "string", required: true, description: "User identifier" }, persona: { type: "string", required: false, description: "Persona type: sales, hiring, default" } },
+        async execute(input, ctx) {
+            const { userId, persona } = input;
+            const qs = { userid: userId };
+            if (persona)
+                qs.persona = persona;
+            return apiRequest(ctx.connection.config.apiKey, "GET", "/user-profile", undefined, qs);
+        },
+    });
+    rl.registerAction("profile.update", {
+        description: "Update a user profile with new data",
+        inputSchema: { userId: { type: "string", required: true, description: "User identifier" }, text: { type: "string", required: false, description: "Additional text" }, linkedinUrl: { type: "string", required: false, description: "LinkedIn URL" } },
+        async execute(input, ctx) {
+            const { userId, text, linkedinUrl } = input;
+            const body = { userid: userId };
+            if (text)
+                body.text = text;
+            if (linkedinUrl)
+                body.linkedin_url = linkedinUrl;
+            return apiRequest(ctx.connection.config.apiKey, "POST", "/user-profile/create", body);
+        },
+    });
+}

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

@@ -0,0 +1,59 @@
+const BASE_URL = "https://api.hunter.io/v2";
+async function apiRequest(apiKey, endpoint, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    url.searchParams.set("api_key", apiKey);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await fetch(url.toString());
+    if (!res.ok)
+        throw new Error(`Hunter API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function hunter(rl) {
+    rl.setName("hunter");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Hunter.io API key", env: "HUNTER_API_KEY" } });
+    rl.registerAction("domainSearch", {
+        description: "Search for email addresses associated with a domain",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Domain name (e.g. example.com)" },
+            type: { type: "string", required: false, description: "personal or generic" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { domain, type, limit } = input;
+            const qs = { domain };
+            if (type)
+                qs.type = type;
+            if (limit)
+                qs.limit = limit;
+            const data = (await apiRequest(ctx.connection.config.apiKey, "/domain-search", qs));
+            return data.data;
+        },
+    });
+    rl.registerAction("emailFinder", {
+        description: "Find the email address of a person",
+        inputSchema: {
+            domain: { type: "string", required: true, description: "Domain" },
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: true, description: "Last name" },
+        },
+        async execute(input, ctx) {
+            const { domain, firstName, lastName } = input;
+            const data = (await apiRequest(ctx.connection.config.apiKey, "/email-finder", { domain, first_name: firstName, last_name: lastName }));
+            return data.data;
+        },
+    });
+    rl.registerAction("emailVerifier", {
+        description: "Verify an email address",
+        inputSchema: { email: { type: "string", required: true, description: "Email to verify" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(ctx.connection.config.apiKey, "/email-verifier", { email: input.email }));
+            return data.data;
+        },
+    });
+}