runline 0.2.1 → 0.2.2

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

@@ -13,13 +13,16 @@ async function api(token, method, endpoint, body, qs, version = "v2") {
                 url.searchParams.set(k, String(v));
         }
     }
-    const init = { method, headers: { Accept: "application/json", "Content-Type": "application/json" } };
+    const init = {
+        method,
+        headers: { Accept: "application/json", "Content-Type": "application/json" },
+    };
     if (body && Object.keys(body).length > 0)
         init.body = JSON.stringify(body);
     const res = await fetch(url.toString(), init);
     if (!res.ok)
         throw new Error(`Pipedrive error ${res.status}: ${await res.text()}`);
-    const json = await res.json();
+    const json = (await res.json());
     if (json.success === false)
         throw new Error(`Pipedrive: ${JSON.stringify(json)}`);
     return json.data ?? json;
@@ -37,14 +40,17 @@ async function paginate(token, endpoint, qs = {}) {
             if (v !== undefined && v !== null)
                 url.searchParams.set(k, String(v));
         }
-        const res = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+        const res = await fetch(url.toString(), {
+            headers: { Accept: "application/json" },
+        });
         if (!res.ok)
             throw new Error(`Pipedrive error ${res.status}: ${await res.text()}`);
-        const json = await res.json();
+        const json = (await res.json());
         const data = json.data;
         if (Array.isArray(data))
             results.push(...data);
-        cursor = json.additional_data?.next_cursor;
+        cursor = json.additional_data
+            ?.next_cursor;
         if (!cursor)
             break;
     } while (true);
@@ -53,13 +59,35 @@ async function paginate(token, endpoint, qs = {}) {
 function registerCrud(rl, resource, endpoint, opts) {
     const cap = resource.charAt(0).toUpperCase() + resource.slice(1);
     const updateMethod = opts?.updateMethod ?? "PATCH";
-    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`,
-        inputSchema: { data: { type: "object", required: true, description: `Fields for the new ${resource}` }, ...(opts?.extraCreate ?? {}) },
-        async execute(input, ctx) { const t = getConn(ctx); return api(t, "POST", endpoint, input.data); } });
-    rl.registerAction(`${resource}.get`, { description: `Get a ${resource}`, inputSchema: { id: { type: "number", required: true } },
-        async execute(input, ctx) { const t = getConn(ctx); return api(t, "GET", `${endpoint}/${input.id}`); } });
-    rl.registerAction(`${resource}.list`, { description: `List ${resource}s`,
-        inputSchema: { limit: { type: "number", required: false }, filterId: { type: "number", required: false } },
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: {
+            data: {
+                type: "object",
+                required: true,
+                description: `Fields for the new ${resource}`,
+            },
+            ...(opts?.extraCreate ?? {}),
+        },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            return api(t, "POST", endpoint, input.data);
+        },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource}`,
+        inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            return api(t, "GET", `${endpoint}/${input.id}`);
+        },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${resource}s`,
+        inputSchema: {
+            limit: { type: "number", required: false },
+            filterId: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const t = getConn(ctx);
             const p = (input ?? {});
@@ -71,15 +99,43 @@ function registerCrud(rl, resource, endpoint, opts) {
                 return api(t, "GET", endpoint, undefined, qs);
             }
             return paginate(t, endpoint, qs);
-        } });
-    rl.registerAction(`${resource}.update`, { description: `Update a ${resource}`,
-        inputSchema: { id: { type: "number", required: true }, data: { type: "object", required: true, description: `Fields to update` }, ...(opts?.extraUpdate ?? {}) },
-        async execute(input, ctx) { const t = getConn(ctx); const p = input; return api(t, updateMethod, `${endpoint}/${p.id}`, p.data); } });
-    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "number", required: true } },
-        async execute(input, ctx) { const t = getConn(ctx); await api(t, "DELETE", `${endpoint}/${input.id}`); return { success: true }; } });
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: {
+            id: { type: "number", required: true },
+            data: { type: "object", required: true, description: `Fields to update` },
+            ...(opts?.extraUpdate ?? {}),
+        },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            const p = input;
+            return api(t, updateMethod, `${endpoint}/${p.id}`, p.data);
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            await api(t, "DELETE", `${endpoint}/${input.id}`);
+            return { success: true };
+        },
+    });
     if (opts?.hasSearch) {
-        rl.registerAction(`${resource}.search`, { description: `Search ${resource}s`,
-            inputSchema: { term: { type: "string", required: true }, exactMatch: { type: "boolean", required: false }, limit: { type: "number", required: false }, fields: { type: "string", required: false, description: "Comma-separated fields to search" } },
+        rl.registerAction(`${resource}.search`, {
+            description: `Search ${resource}s`,
+            inputSchema: {
+                term: { type: "string", required: true },
+                exactMatch: { type: "boolean", required: false },
+                limit: { type: "number", required: false },
+                fields: {
+                    type: "string",
+                    required: false,
+                    description: "Comma-separated fields to search",
+                },
+            },
             async execute(input, ctx) {
                 const t = getConn(ctx);
                 const p = input;
@@ -91,37 +147,74 @@ function registerCrud(rl, resource, endpoint, opts) {
                 if (p.fields)
                     qs.fields = p.fields;
                 // Search uses v1 API
-                const res = await api(t, "GET", `${endpoint}/search`, undefined, qs, "v1");
+                const res = (await api(t, "GET", `${endpoint}/search`, undefined, qs, "v1"));
                 if (Array.isArray(res))
                     return res.map((r) => r.item ?? r);
                 return res;
-            } });
+            },
+        });
     }
     if (opts?.hasDuplicate) {
-        rl.registerAction(`${resource}.duplicate`, { description: `Duplicate a ${resource}`, inputSchema: { id: { type: "number", required: true } },
-            async execute(input, ctx) { const t = getConn(ctx); return api(t, "POST", `${endpoint}/${input.id}/duplicate`); } });
+        rl.registerAction(`${resource}.duplicate`, {
+            description: `Duplicate a ${resource}`,
+            inputSchema: { id: { type: "number", required: true } },
+            async execute(input, ctx) {
+                const t = getConn(ctx);
+                return api(t, "POST", `${endpoint}/${input.id}/duplicate`);
+            },
+        });
     }
 }
 export default function pipedrive(rl) {
     rl.setName("pipedrive");
     rl.setVersion("0.1.0");
     rl.setConnectionSchema({
-        apiToken: { type: "string", required: true, description: "Pipedrive API token", env: "PIPEDRIVE_API_TOKEN" },
+        apiToken: {
+            type: "string",
+            required: true,
+            description: "Pipedrive API token",
+            env: "PIPEDRIVE_API_TOKEN",
+        },
     });
     // ── Activity ────────────────────────────────────────
     registerCrud(rl, "activity", "/activities");
     // ── Deal ────────────────────────────────────────────
     registerCrud(rl, "deal", "/deals", { hasSearch: true, hasDuplicate: true });
     // ── Deal Product ────────────────────────────────────
-    rl.registerAction("dealProduct.add", { description: "Add a product to a deal",
-        inputSchema: { dealId: { type: "number", required: true }, productId: { type: "number", required: true }, itemPrice: { type: "number", required: true }, quantity: { type: "number", required: true }, discount: { type: "number", required: false }, discountType: { type: "string", required: false, description: "percentage or amount" }, comments: { type: "string", required: false } },
+    rl.registerAction("dealProduct.add", {
+        description: "Add a product to a deal",
+        inputSchema: {
+            dealId: { type: "number", required: true },
+            productId: { type: "number", required: true },
+            itemPrice: { type: "number", required: true },
+            quantity: { type: "number", required: true },
+            discount: { type: "number", required: false },
+            discountType: {
+                type: "string",
+                required: false,
+                description: "percentage or amount",
+            },
+            comments: { type: "string", required: false },
+        },
         async execute(input, ctx) {
             const t = getConn(ctx);
             const { dealId, ...body } = input;
-            return api(t, "POST", `/deals/${dealId}/products`, { product_id: body.productId, item_price: body.itemPrice, quantity: body.quantity, ...(body.discount !== undefined ? { discount: body.discount } : {}), ...(body.discountType ? { discount_type: body.discountType } : {}), ...(body.comments ? { comments: body.comments } : {}) });
-        } });
-    rl.registerAction("dealProduct.list", { description: "List products of a deal",
-        inputSchema: { dealId: { type: "number", required: true }, limit: { type: "number", required: false } },
+            return api(t, "POST", `/deals/${dealId}/products`, {
+                product_id: body.productId,
+                item_price: body.itemPrice,
+                quantity: body.quantity,
+                ...(body.discount !== undefined ? { discount: body.discount } : {}),
+                ...(body.discountType ? { discount_type: body.discountType } : {}),
+                ...(body.comments ? { comments: body.comments } : {}),
+            });
+        },
+    });
+    rl.registerAction("dealProduct.list", {
+        description: "List products of a deal",
+        inputSchema: {
+            dealId: { type: "number", required: true },
+            limit: { type: "number", required: false },
+        },
         async execute(input, ctx) {
             const t = getConn(ctx);
             const p = input;
@@ -129,33 +222,62 @@ export default function pipedrive(rl) {
             if (p.limit)
                 qs.limit = p.limit;
             return api(t, "GET", `/deals/${p.dealId}/products`, undefined, qs);
-        } });
-    rl.registerAction("dealProduct.update", { description: "Update a product in a deal",
-        inputSchema: { dealId: { type: "number", required: true }, productAttachmentId: { type: "number", required: true }, data: { type: "object", required: true } },
+        },
+    });
+    rl.registerAction("dealProduct.update", {
+        description: "Update a product in a deal",
+        inputSchema: {
+            dealId: { type: "number", required: true },
+            productAttachmentId: { type: "number", required: true },
+            data: { type: "object", required: true },
+        },
         async execute(input, ctx) {
             const t = getConn(ctx);
             const p = input;
             return api(t, "PATCH", `/deals/${p.dealId}/products/${p.productAttachmentId}`, p.data);
-        } });
-    rl.registerAction("dealProduct.remove", { description: "Remove a product from a deal",
-        inputSchema: { dealId: { type: "number", required: true }, productAttachmentId: { type: "number", required: true } },
+        },
+    });
+    rl.registerAction("dealProduct.remove", {
+        description: "Remove a product from a deal",
+        inputSchema: {
+            dealId: { type: "number", required: true },
+            productAttachmentId: { type: "number", required: true },
+        },
         async execute(input, ctx) {
             const t = getConn(ctx);
             const p = input;
             await api(t, "DELETE", `/deals/${p.dealId}/products/${p.productAttachmentId}`);
             return { success: true };
-        } });
+        },
+    });
     // ── File (skip create/download — binary) ────────────
-    rl.registerAction("file.get", { description: "Get file metadata", inputSchema: { id: { type: "number", required: true } },
-        async execute(input, ctx) { return api(getConn(ctx), "GET", `/files/${input.id}`, undefined, undefined, "v1"); } });
-    rl.registerAction("file.delete", { description: "Delete a file", inputSchema: { id: { type: "number", required: true } },
-        async execute(input, ctx) { await api(getConn(ctx), "DELETE", `/files/${input.id}`, undefined, undefined, "v1"); return { success: true }; } });
-    rl.registerAction("file.update", { description: "Update file metadata",
-        inputSchema: { id: { type: "number", required: true }, name: { type: "string", required: false }, description: { type: "string", required: false } },
+    rl.registerAction("file.get", {
+        description: "Get file metadata",
+        inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) {
+            return api(getConn(ctx), "GET", `/files/${input.id}`, undefined, undefined, "v1");
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file",
+        inputSchema: { id: { type: "number", required: true } },
+        async execute(input, ctx) {
+            await api(getConn(ctx), "DELETE", `/files/${input.id}`, undefined, undefined, "v1");
+            return { success: true };
+        },
+    });
+    rl.registerAction("file.update", {
+        description: "Update file metadata",
+        inputSchema: {
+            id: { type: "number", required: true },
+            name: { type: "string", required: false },
+            description: { type: "string", required: false },
+        },
         async execute(input, ctx) {
             const { id, ...body } = input;
             return api(getConn(ctx), "PUT", `/files/${id}`, body, undefined, "v1");
-        } });
+        },
+    });
     // ── Lead ────────────────────────────────────────────
     registerCrud(rl, "lead", "/leads");
     // ── Note ────────────────────────────────────────────

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

@@ -20,8 +20,18 @@ export default function plivo(rl) {
     rl.setName("plivo");
     rl.setVersion("0.1.0");
     rl.setConnectionSchema({
-        authId: { type: "string", required: true, description: "Plivo Auth ID", env: "PLIVO_AUTH_ID" },
-        authToken: { type: "string", required: true, description: "Plivo Auth Token", env: "PLIVO_AUTH_TOKEN" },
+        authId: {
+            type: "string",
+            required: true,
+            description: "Plivo Auth ID",
+            env: "PLIVO_AUTH_ID",
+        },
+        authToken: {
+            type: "string",
+            required: true,
+            description: "Plivo Auth Token",
+            env: "PLIVO_AUTH_TOKEN",
+        },
     });
     rl.registerAction("sms.send", {
         description: "Send an SMS message via Plivo",
@@ -32,7 +42,11 @@ export default function plivo(rl) {
         },
         async execute(input, ctx) {
             const { from, to, message } = input;
-            return apiRequest(getConn(ctx), "POST", "/Message", { src: from, dst: to, text: message });
+            return apiRequest(getConn(ctx), "POST", "/Message", {
+                src: from,
+                dst: to,
+                text: message,
+            });
         },
     });
     rl.registerAction("mms.send", {
@@ -41,11 +55,21 @@ export default function plivo(rl) {
             from: { type: "string", required: true, description: "Sender number" },
             to: { type: "string", required: true, description: "Recipient number" },
             message: { type: "string", required: true },
-            mediaUrls: { type: "string", required: true, description: "Comma-separated media URLs" },
+            mediaUrls: {
+                type: "string",
+                required: true,
+                description: "Comma-separated media URLs",
+            },
         },
         async execute(input, ctx) {
             const { from, to, message, mediaUrls } = input;
-            return apiRequest(getConn(ctx), "POST", "/Message", { src: from, dst: to, text: message, type: "mms", media_urls: mediaUrls });
+            return apiRequest(getConn(ctx), "POST", "/Message", {
+                src: from,
+                dst: to,
+                text: message,
+                type: "mms",
+                media_urls: mediaUrls,
+            });
         },
     });
     rl.registerAction("call.make", {
@@ -53,13 +77,24 @@ export default function plivo(rl) {
         inputSchema: {
             from: { type: "string", required: true, description: "Caller number" },
             to: { type: "string", required: true, description: "Destination number" },
-            answerUrl: { type: "string", required: true, description: "URL for call answer XML" },
-            answerMethod: { type: "string", required: false, description: "HTTP method for answer URL (GET or POST, default POST)" },
+            answerUrl: {
+                type: "string",
+                required: true,
+                description: "URL for call answer XML",
+            },
+            answerMethod: {
+                type: "string",
+                required: false,
+                description: "HTTP method for answer URL (GET or POST, default POST)",
+            },
         },
         async execute(input, ctx) {
             const { from, to, answerUrl, answerMethod } = input;
             return apiRequest(getConn(ctx), "POST", "/Call", {
-                from, to, answer_url: answerUrl, answer_method: answerMethod ?? "POST",
+                from,
+                to,
+                answer_url: answerUrl,
+                answer_method: answerMethod ?? "POST",
             });
         },
     });

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

@@ -1,6 +1,9 @@
 const BASE = "https://www.postb.in";
 async function apiRequest(method, path, body) {
-    const init = { method, headers: { "Content-Type": "application/json" } };
+    const init = {
+        method,
+        headers: { "Content-Type": "application/json" },
+    };
     if (body !== undefined)
         init.body = body;
     const res = await fetch(`${BASE}${path}`, init);
@@ -81,7 +84,11 @@ export default function postbin(rl) {
         description: "Send a test request to a bin",
         inputSchema: {
             binId: { type: "string", required: true },
-            content: { type: "string", required: false, description: "Request body content" },
+            content: {
+                type: "string",
+                required: false,
+                description: "Request body content",
+            },
         },
         async execute(input) {
             const p = input;

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

@@ -1,6 +1,9 @@
 function getConn(ctx) {
     const c = ctx.connection.config;
-    return { url: c.url.replace(/\/$/, ""), apiKey: c.apiKey };
+    return {
+        url: c.url.replace(/\/$/, ""),
+        apiKey: c.apiKey,
+    };
 }
 async function apiRequest(conn, endpoint, body) {
     body.api_key = conn.apiKey;
@@ -17,21 +20,40 @@ export default function posthog(rl) {
     rl.setName("posthog");
     rl.setVersion("0.1.0");
     rl.setConnectionSchema({
-        url: { type: "string", required: true, description: "PostHog instance URL (e.g. https://app.posthog.com)", env: "POSTHOG_URL" },
-        apiKey: { type: "string", required: true, description: "PostHog project API key", env: "POSTHOG_API_KEY" },
+        url: {
+            type: "string",
+            required: true,
+            description: "PostHog instance URL (e.g. https://app.posthog.com)",
+            env: "POSTHOG_URL",
+        },
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "PostHog project API key",
+            env: "POSTHOG_API_KEY",
+        },
     });
     rl.registerAction("alias.create", {
         description: "Create an alias for a distinct ID",
         inputSchema: {
             distinctId: { type: "string", required: true },
             alias: { type: "string", required: true },
-            context: { type: "object", required: false, description: "Context key-value pairs" },
-            timestamp: { type: "string", required: false, description: "ISO 8601 timestamp" },
+            context: {
+                type: "object",
+                required: false,
+                description: "Context key-value pairs",
+            },
+            timestamp: {
+                type: "string",
+                required: false,
+                description: "ISO 8601 timestamp",
+            },
         },
         async execute(input, ctx) {
             const p = input;
             const body = {
-                type: "alias", event: "$create_alias",
+                type: "alias",
+                event: "$create_alias",
                 context: p.context ?? {},
                 properties: { distinct_id: p.distinctId, alias: p.alias },
             };
@@ -43,7 +65,11 @@ export default function posthog(rl) {
     rl.registerAction("event.create", {
         description: "Capture one or more events",
         inputSchema: {
-            events: { type: "object", required: true, description: "Array of event objects: [{event, distinct_id, properties?, timestamp?}]" },
+            events: {
+                type: "object",
+                required: true,
+                description: "Array of event objects: [{event, distinct_id, properties?, timestamp?}]",
+            },
         },
         async execute(input, ctx) {
             const { events } = input;
@@ -54,13 +80,18 @@ export default function posthog(rl) {
         description: "Identify a user (set person properties)",
         inputSchema: {
             distinctId: { type: "string", required: true },
-            properties: { type: "object", required: false, description: "Person properties to set" },
+            properties: {
+                type: "object",
+                required: false,
+                description: "Person properties to set",
+            },
             timestamp: { type: "string", required: false },
         },
         async execute(input, ctx) {
             const p = input;
             const body = {
-                event: "$identify", distinct_id: p.distinctId,
+                event: "$identify",
+                distinct_id: p.distinctId,
                 properties: p.properties ?? {},
             };
             if (p.timestamp)
@@ -80,9 +111,12 @@ export default function posthog(rl) {
         async execute(input, ctx) {
             const p = input;
             const body = {
-                type: "page", event: "$page", name: p.name,
+                type: "page",
+                event: "$page",
+                name: p.name,
                 distinct_id: p.distinctId,
-                properties: p.properties ?? {}, context: p.context ?? {},
+                properties: p.properties ?? {},
+                context: p.context ?? {},
             };
             if (p.timestamp)
                 body.timestamp = p.timestamp;
@@ -101,9 +135,12 @@ export default function posthog(rl) {
         async execute(input, ctx) {
             const p = input;
             const body = {
-                type: "screen", event: "$screen", name: p.name,
+                type: "screen",
+                event: "$screen",
+                name: p.name,
                 distinct_id: p.distinctId,
-                properties: p.properties ?? {}, context: p.context ?? {},
+                properties: p.properties ?? {},
+                context: p.context ?? {},
             };
             if (p.timestamp)
                 body.timestamp = p.timestamp;

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

@@ -7,7 +7,9 @@ async function apiRequest(token, endpoint, qs) {
                 url.searchParams.set(k, String(v));
         }
     }
-    const res = await fetch(url.toString(), { headers: { Authorization: token } });
+    const res = await fetch(url.toString(), {
+        headers: { Authorization: token },
+    });
     if (!res.ok)
         throw new Error(`ProfitWell error ${res.status}: ${await res.text()}`);
     return res.json();
@@ -16,7 +18,12 @@ export default function profitwell(rl) {
     rl.setName("profitwell");
     rl.setVersion("0.1.0");
     rl.setConnectionSchema({
-        accessToken: { type: "string", required: true, description: "ProfitWell API access token", env: "PROFITWELL_ACCESS_TOKEN" },
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "ProfitWell API access token",
+            env: "PROFITWELL_ACCESS_TOKEN",
+        },
     });
     const key = (ctx) => ctx.connection.config.accessToken;
     rl.registerAction("company.getSettings", {
@@ -30,9 +37,21 @@ export default function profitwell(rl) {
         description: "Get financial metrics (daily or monthly)",
         inputSchema: {
             type: { type: "string", required: true, description: "daily or monthly" },
-            month: { type: "string", required: false, description: "Month (YYYY-MM) — required for daily metrics" },
-            metrics: { type: "string", required: false, description: "Comma-separated metric names to retrieve" },
-            planId: { type: "string", required: false, description: "Filter by plan ID" },
+            month: {
+                type: "string",
+                required: false,
+                description: "Month (YYYY-MM) — required for daily metrics",
+            },
+            metrics: {
+                type: "string",
+                required: false,
+                description: "Comma-separated metric names to retrieve",
+            },
+            planId: {
+                type: "string",
+                required: false,
+                description: "Filter by plan ID",
+            },
         },
         async execute(input, ctx) {
             const p = (input ?? {});