runline 0.1.0

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

@@ -0,0 +1,169 @@
+const V2 = "https://api.pipedrive.com/api/v2";
+const V1 = "https://api.pipedrive.com/v1";
+function getConn(ctx) {
+    return ctx.connection.config.apiToken;
+}
+async function api(token, method, endpoint, body, qs, version = "v2") {
+    const base = version === "v1" ? V1 : V2;
+    const url = new URL(`${base}${endpoint}`);
+    url.searchParams.set("api_token", token);
+    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: { 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();
+    if (json.success === false)
+        throw new Error(`Pipedrive: ${JSON.stringify(json)}`);
+    return json.data ?? json;
+}
+async function paginate(token, endpoint, qs = {}) {
+    const results = [];
+    qs.limit = 500;
+    let cursor;
+    do {
+        if (cursor)
+            qs.cursor = cursor;
+        const url = new URL(`${V2}${endpoint}`);
+        url.searchParams.set("api_token", token);
+        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(), { headers: { Accept: "application/json" } });
+        if (!res.ok)
+            throw new Error(`Pipedrive error ${res.status}: ${await res.text()}`);
+        const json = await res.json();
+        const data = json.data;
+        if (Array.isArray(data))
+            results.push(...data);
+        cursor = json.additional_data?.next_cursor;
+        if (!cursor)
+            break;
+    } while (true);
+    return results;
+}
+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 } },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            const p = (input ?? {});
+            const qs = {};
+            if (p.filterId)
+                qs.filter_id = p.filterId;
+            if (p.limit) {
+                qs.limit = p.limit;
+                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 }; } });
+    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" } },
+            async execute(input, ctx) {
+                const t = getConn(ctx);
+                const p = input;
+                const qs = { term: p.term };
+                if (p.exactMatch)
+                    qs.exact_match = true;
+                if (p.limit)
+                    qs.limit = p.limit;
+                if (p.fields)
+                    qs.fields = p.fields;
+                // Search uses v1 API
+                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`); } });
+    }
+}
+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" },
+    });
+    // ── 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 } },
+        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 } },
+        async execute(input, ctx) {
+            const t = getConn(ctx);
+            const p = input;
+            const qs = {};
+            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 } },
+        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 } },
+        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 } },
+        async execute(input, ctx) {
+            const { id, ...body } = input;
+            return api(getConn(ctx), "PUT", `/files/${id}`, body, undefined, "v1");
+        } });
+    // ── Lead ────────────────────────────────────────────
+    registerCrud(rl, "lead", "/leads");
+    // ── Note ────────────────────────────────────────────
+    registerCrud(rl, "note", "/notes");
+    // ── Organization ────────────────────────────────────
+    registerCrud(rl, "organization", "/organizations", { hasSearch: true });
+    // ── Person ──────────────────────────────────────────
+    registerCrud(rl, "person", "/persons", { hasSearch: true });
+    // ── Product ─────────────────────────────────────────
+    registerCrud(rl, "product", "/products", { hasSearch: true });
+}

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

@@ -0,0 +1,66 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { authId: c.authId, authToken: c.authToken };
+}
+async function apiRequest(conn, method, endpoint, body) {
+    const url = `https://api.plivo.com/v1/Account/${conn.authId}${endpoint}/`;
+    const res = await fetch(url, {
+        method,
+        headers: {
+            Authorization: "Basic " + btoa(`${conn.authId}:${conn.authToken}`),
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Plivo error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+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" },
+    });
+    rl.registerAction("sms.send", {
+        description: "Send an SMS message via Plivo",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender number" },
+            to: { type: "string", required: true, description: "Recipient number" },
+            message: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { from, to, message } = input;
+            return apiRequest(getConn(ctx), "POST", "/Message", { src: from, dst: to, text: message });
+        },
+    });
+    rl.registerAction("mms.send", {
+        description: "Send an MMS message via Plivo",
+        inputSchema: {
+            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" },
+        },
+        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 });
+        },
+    });
+    rl.registerAction("call.make", {
+        description: "Make a phone call via Plivo",
+        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)" },
+        },
+        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",
+            });
+        },
+    });
+}

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

@@ -0,0 +1,93 @@
+const BASE = "https://www.postb.in";
+async function apiRequest(method, path, body) {
+    const init = { method, headers: { "Content-Type": "application/json" } };
+    if (body !== undefined)
+        init.body = body;
+    const res = await fetch(`${BASE}${path}`, init);
+    if (!res.ok)
+        throw new Error(`PostBin error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+function parseBinId(binId) {
+    const match = /\b\d{13}-\d{13}\b/.exec(binId);
+    if (!match)
+        throw new Error(`Invalid Bin ID format: ${binId}`);
+    return match[0];
+}
+function transformBin(data) {
+    const binId = data.binId;
+    return {
+        binId,
+        nowTimestamp: data.now,
+        nowIso: new Date(data.now).toISOString(),
+        expiresTimestamp: data.expires,
+        expiresIso: new Date(data.expires).toISOString(),
+        requestUrl: `${BASE}/${binId}`,
+        viewUrl: `${BASE}/b/${binId}`,
+    };
+}
+export default function postbin(rl) {
+    rl.setName("postbin");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({});
+    rl.registerAction("bin.create", {
+        description: "Create a new PostBin bin (no auth required)",
+        inputSchema: {},
+        async execute() {
+            const data = (await apiRequest("POST", "/api/bin"));
+            return transformBin(data);
+        },
+    });
+    rl.registerAction("bin.get", {
+        description: "Get a bin's info",
+        inputSchema: { binId: { type: "string", required: true } },
+        async execute(input) {
+            const id = parseBinId(input.binId);
+            const data = (await apiRequest("GET", `/api/bin/${id}`));
+            return transformBin(data);
+        },
+    });
+    rl.registerAction("bin.delete", {
+        description: "Delete a bin",
+        inputSchema: { binId: { type: "string", required: true } },
+        async execute(input) {
+            const id = parseBinId(input.binId);
+            await apiRequest("DELETE", `/api/bin/${id}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("request.get", {
+        description: "Get a specific request from a bin",
+        inputSchema: {
+            binId: { type: "string", required: true },
+            requestId: { type: "string", required: true },
+        },
+        async execute(input) {
+            const p = input;
+            const id = parseBinId(p.binId);
+            return apiRequest("GET", `/api/bin/${id}/req/${p.requestId}`);
+        },
+    });
+    rl.registerAction("request.removeFirst", {
+        description: "Remove and return the first request from a bin",
+        inputSchema: { binId: { type: "string", required: true } },
+        async execute(input) {
+            const id = parseBinId(input.binId);
+            return apiRequest("GET", `/api/bin/${id}/req/shift`);
+        },
+    });
+    rl.registerAction("request.send", {
+        description: "Send a test request to a bin",
+        inputSchema: {
+            binId: { type: "string", required: true },
+            content: { type: "string", required: false, description: "Request body content" },
+        },
+        async execute(input) {
+            const p = input;
+            const id = parseBinId(p.binId);
+            const data = await apiRequest("POST", `/${id}`, p.content ? JSON.stringify({ content: p.content }) : undefined);
+            return { requestId: data };
+        },
+    });
+}

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

@@ -0,0 +1,113 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), apiKey: c.apiKey };
+}
+async function apiRequest(conn, endpoint, body) {
+    body.api_key = conn.apiKey;
+    const res = await fetch(`${conn.url}${endpoint}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`PostHog error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+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" },
+    });
+    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" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                type: "alias", event: "$create_alias",
+                context: p.context ?? {},
+                properties: { distinct_id: p.distinctId, alias: p.alias },
+            };
+            if (p.timestamp)
+                body.timestamp = p.timestamp;
+            return apiRequest(getConn(ctx), "/batch", body);
+        },
+    });
+    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?}]" },
+        },
+        async execute(input, ctx) {
+            const { events } = input;
+            return apiRequest(getConn(ctx), "/capture", { batch: events });
+        },
+    });
+    rl.registerAction("identity.create", {
+        description: "Identify a user (set person properties)",
+        inputSchema: {
+            distinctId: { type: "string", required: true },
+            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,
+                properties: p.properties ?? {},
+            };
+            if (p.timestamp)
+                body.timestamp = p.timestamp;
+            return apiRequest(getConn(ctx), "/batch", body);
+        },
+    });
+    rl.registerAction("track.page", {
+        description: "Track a page view",
+        inputSchema: {
+            distinctId: { type: "string", required: true },
+            name: { type: "string", required: true, description: "Page name" },
+            properties: { type: "object", required: false },
+            context: { type: "object", required: false },
+            timestamp: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                type: "page", event: "$page", name: p.name,
+                distinct_id: p.distinctId,
+                properties: p.properties ?? {}, context: p.context ?? {},
+            };
+            if (p.timestamp)
+                body.timestamp = p.timestamp;
+            return apiRequest(getConn(ctx), "/batch", body);
+        },
+    });
+    rl.registerAction("track.screen", {
+        description: "Track a screen view",
+        inputSchema: {
+            distinctId: { type: "string", required: true },
+            name: { type: "string", required: true, description: "Screen name" },
+            properties: { type: "object", required: false },
+            context: { type: "object", required: false },
+            timestamp: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                type: "screen", event: "$screen", name: p.name,
+                distinct_id: p.distinctId,
+                properties: p.properties ?? {}, context: p.context ?? {},
+            };
+            if (p.timestamp)
+                body.timestamp = p.timestamp;
+            return apiRequest(getConn(ctx), "/batch", body);
+        },
+    });
+}

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

@@ -0,0 +1,50 @@
+const BASE = "https://api.profitwell.com/v2";
+async function apiRequest(token, endpoint, qs) {
+    const url = new URL(`${BASE}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const res = await fetch(url.toString(), { headers: { Authorization: token } });
+    if (!res.ok)
+        throw new Error(`ProfitWell error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+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" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("company.getSettings", {
+        description: "Get company settings",
+        inputSchema: {},
+        async execute(_input, ctx) {
+            return apiRequest(key(ctx), "/company/settings/");
+        },
+    });
+    rl.registerAction("metric.get", {
+        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" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.month)
+                qs.month = p.month;
+            if (p.metrics)
+                qs.metrics = p.metrics;
+            if (p.planId)
+                qs.plan_id = p.planId;
+            const data = (await apiRequest(key(ctx), `/metrics/${p.type}`, qs));
+            return data.data;
+        },
+    });
+}

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

@@ -0,0 +1,102 @@
+const BASE = "https://api.pushbullet.com/v2";
+async function apiRequest(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: { "Access-Token": token, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Pushbullet error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+async function paginate(token, path, qs = {}) {
+    const all = [];
+    let cursor;
+    do {
+        if (cursor)
+            qs.cursor = cursor;
+        const data = (await apiRequest(token, "GET", path, undefined, qs));
+        const items = (data.pushes ?? []);
+        all.push(...items);
+        cursor = data.cursor;
+    } while (cursor);
+    return all;
+}
+export default function pushbullet(rl) {
+    rl.setName("pushbullet");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Pushbullet Access Token", env: "PUSHBULLET_ACCESS_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("push.create", {
+        description: "Create a push (note or link)",
+        inputSchema: {
+            type: { type: "string", required: true, description: "note or link" },
+            title: { type: "string", required: true },
+            body: { type: "string", required: true },
+            url: { type: "string", required: false, description: "URL (required for link type)" },
+            target: { type: "string", required: false, description: "Target: default, device_iden, email, channel_tag" },
+            targetValue: { type: "string", required: false, description: "Value for target (device ID, email, or channel tag)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const reqBody = { type: p.type, title: p.title, body: p.body };
+            if (p.type === "link" && p.url)
+                reqBody.url = p.url;
+            const target = p.target ?? "default";
+            if (target !== "default" && p.targetValue)
+                reqBody[target] = p.targetValue;
+            return apiRequest(key(ctx), "POST", "/pushes", reqBody);
+        },
+    });
+    rl.registerAction("push.list", {
+        description: "List pushes",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            active: { type: "boolean", required: false, description: "Only return non-deleted pushes" },
+            modifiedAfter: { type: "string", required: false, description: "ISO timestamp — only return pushes modified after this" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.active)
+                qs.active = "true";
+            if (p.modifiedAfter)
+                qs.modified_after = String(Math.floor(new Date(p.modifiedAfter).getTime() / 1000));
+            if (p.limit) {
+                qs.limit = p.limit;
+                const d = (await apiRequest(key(ctx), "GET", "/pushes", undefined, qs));
+                return d.pushes;
+            }
+            return paginate(key(ctx), "/pushes", qs);
+        },
+    });
+    rl.registerAction("push.delete", {
+        description: "Delete a push",
+        inputSchema: { pushId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { pushId } = input;
+            await apiRequest(key(ctx), "DELETE", `/pushes/${pushId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("push.update", {
+        description: "Update a push (dismiss it)",
+        inputSchema: {
+            pushId: { type: "string", required: true },
+            dismissed: { type: "boolean", required: true, description: "Mark push as dismissed" },
+        },
+        async execute(input, ctx) {
+            const { pushId, dismissed } = input;
+            return apiRequest(key(ctx), "POST", `/pushes/${pushId}`, { dismissed });
+        },
+    });
+}

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

@@ -0,0 +1,39 @@
+const BASE = "https://api.pushcut.io/v1";
+export default function pushcut(rl) {
+    rl.setName("pushcut");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Pushcut API key", env: "PUSHCUT_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("notification.send", {
+        description: "Send a Pushcut notification",
+        inputSchema: {
+            notificationName: { type: "string", required: true, description: "Notification name or ID" },
+            text: { type: "string", required: false, description: "Override notification text" },
+            title: { type: "string", required: false, description: "Override notification title" },
+            input: { type: "string", required: false, description: "Value passed as input to the action" },
+            devices: { type: "object", required: false, description: "Array of device IDs (default: all)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.text)
+                body.text = p.text;
+            if (p.title)
+                body.title = p.title;
+            if (p.input)
+                body.input = p.input;
+            if (p.devices)
+                body.devices = p.devices;
+            const res = await fetch(`${BASE}/notifications/${encodeURIComponent(p.notificationName)}`, {
+                method: "POST",
+                headers: { "API-Key": key(ctx), "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`Pushcut error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}