runline 0.1.0

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

@@ -0,0 +1,201 @@
+const BASE = "https://api.pagerduty.com";
+function getToken(ctx) { return ctx.connection.config.apiToken; }
+async function apiRequest(token, method, endpoint, body, qs, extraHeaders) {
+    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 headers = {
+        Authorization: `Token token=${token}`,
+        Accept: "application/vnd.pagerduty+json;version=2",
+        "Content-Type": "application/json",
+        ...extraHeaders,
+    };
+    const init = { method, headers };
+    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(`PagerDuty API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+async function paginate(token, endpoint, propertyName, qs = {}) {
+    const all = [];
+    qs.limit = 100;
+    qs.offset = 0;
+    let hasMore = true;
+    while (hasMore) {
+        const data = (await apiRequest(token, "GET", endpoint, undefined, qs));
+        const items = (data[propertyName] ?? []);
+        all.push(...items);
+        hasMore = data.more === true;
+        qs.offset = qs.offset + qs.limit;
+    }
+    return all;
+}
+export default function pagerduty(rl) {
+    rl.setName("pagerduty");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: { type: "string", required: true, description: "PagerDuty API token", env: "PAGERDUTY_API_TOKEN" },
+    });
+    // ── Incident ────────────────────────────────────────
+    rl.registerAction("incident.create", {
+        description: "Create a new incident",
+        inputSchema: {
+            title: { type: "string", required: true },
+            serviceId: { type: "string", required: true, description: "Service ID" },
+            from: { type: "string", required: true, description: "Email of the user creating the incident" },
+            urgency: { type: "string", required: false, description: "high or low" },
+            details: { type: "string", required: false, description: "Incident body details" },
+            priorityId: { type: "string", required: false },
+            escalationPolicyId: { type: "string", required: false },
+            incidentKey: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const incident = {
+                type: "incident", title: p.title,
+                service: { id: p.serviceId, type: "service_reference" },
+            };
+            if (p.urgency)
+                incident.urgency = p.urgency;
+            if (p.details)
+                incident.body = { type: "incident_body", details: p.details };
+            if (p.priorityId)
+                incident.priority = { id: p.priorityId, type: "priority_reference" };
+            if (p.escalationPolicyId)
+                incident.escalation_policy = { id: p.escalationPolicyId, type: "escalation_policy_reference" };
+            if (p.incidentKey)
+                incident.incident_key = p.incidentKey;
+            const data = (await apiRequest(getToken(ctx), "POST", "/incidents", { incident }, undefined, { From: p.from }));
+            return data.incident;
+        },
+    });
+    rl.registerAction("incident.get", {
+        description: "Get an incident by ID",
+        inputSchema: { incidentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { incidentId } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `/incidents/${incidentId}`));
+            return data.incident;
+        },
+    });
+    rl.registerAction("incident.list", {
+        description: "List incidents",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            statuses: { type: "string", required: false, description: "Comma-separated: triggered,acknowledged,resolved" },
+            sortBy: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.statuses)
+                qs["statuses[]"] = p.statuses;
+            if (p.sortBy)
+                qs.sort_by = p.sortBy;
+            if (p.limit) {
+                qs.limit = p.limit;
+                const d = (await apiRequest(getToken(ctx), "GET", "/incidents", undefined, qs));
+                return d.incidents;
+            }
+            return paginate(getToken(ctx), "/incidents", "incidents", qs);
+        },
+    });
+    rl.registerAction("incident.update", {
+        description: "Update an incident",
+        inputSchema: {
+            incidentId: { type: "string", required: true },
+            from: { type: "string", required: true, description: "Email of the user updating" },
+            title: { type: "string", required: false },
+            status: { type: "string", required: false, description: "acknowledged, resolved" },
+            urgency: { type: "string", required: false },
+            resolution: { type: "string", required: false },
+            escalationLevel: { type: "number", required: false },
+            priorityId: { type: "string", required: false },
+            escalationPolicyId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const incident = { type: "incident" };
+            if (p.title)
+                incident.title = p.title;
+            if (p.status)
+                incident.status = p.status;
+            if (p.urgency)
+                incident.urgency = p.urgency;
+            if (p.resolution)
+                incident.resolution = p.resolution;
+            if (p.escalationLevel)
+                incident.escalation_level = p.escalationLevel;
+            if (p.priorityId)
+                incident.priority = { id: p.priorityId, type: "priority_reference" };
+            if (p.escalationPolicyId)
+                incident.escalation_policy = { id: p.escalationPolicyId, type: "escalation_policy_reference" };
+            const data = (await apiRequest(getToken(ctx), "PUT", `/incidents/${p.incidentId}`, { incident }, undefined, { From: p.from }));
+            return data.incident;
+        },
+    });
+    // ── Incident Note ───────────────────────────────────
+    rl.registerAction("incidentNote.create", {
+        description: "Add a note to an incident",
+        inputSchema: {
+            incidentId: { type: "string", required: true },
+            from: { type: "string", required: true, description: "Email of the user" },
+            content: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { incidentId, from, content } = input;
+            return apiRequest(getToken(ctx), "POST", `/incidents/${incidentId}/notes`, { note: { content } }, undefined, { From: from });
+        },
+    });
+    rl.registerAction("incidentNote.list", {
+        description: "List notes for an incident",
+        inputSchema: { incidentId: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await apiRequest(getToken(ctx), "GET", `/incidents/${p.incidentId}/notes`, undefined, qs));
+            return data.notes;
+        },
+    });
+    // ── Log Entry ───────────────────────────────────────
+    rl.registerAction("logEntry.get", {
+        description: "Get a log entry by ID",
+        inputSchema: { logEntryId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { logEntryId } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `/log_entries/${logEntryId}`));
+            return data.log_entry;
+        },
+    });
+    rl.registerAction("logEntry.list", {
+        description: "List log entries",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            if (p.limit) {
+                const data = (await apiRequest(getToken(ctx), "GET", "/log_entries", undefined, { limit: p.limit }));
+                return data.log_entries;
+            }
+            return paginate(getToken(ctx), "/log_entries", "log_entries");
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get a user by ID",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { userId } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `/users/${userId}`));
+            return data.user;
+        },
+    });
+}

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

@@ -0,0 +1,106 @@
+let cachedToken = null;
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const env = c.env ?? "sandbox";
+    const base = env === "live" ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com";
+    return { base, clientId: c.clientId, secret: c.secret };
+}
+async function getAccessToken(conn) {
+    if (cachedToken && Date.now() < cachedToken.expiresAt)
+        return cachedToken.token;
+    const res = await fetch(`${conn.base}/v1/oauth2/token`, {
+        method: "POST",
+        headers: {
+            Authorization: "Basic " + btoa(`${conn.clientId}:${conn.secret}`),
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: "grant_type=client_credentials",
+    });
+    if (!res.ok)
+        throw new Error(`PayPal auth error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    cachedToken = { token: data.access_token, expiresAt: Date.now() + (data.expires_in - 60) * 1000 };
+    return cachedToken.token;
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const token = await getAccessToken(conn);
+    const url = new URL(`${conn.base}/v1${endpoint}`);
+    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" },
+    };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`PayPal API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function paypal(rl) {
+    rl.setName("paypal");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        clientId: { type: "string", required: true, description: "PayPal client ID", env: "PAYPAL_CLIENT_ID" },
+        secret: { type: "string", required: true, description: "PayPal secret", env: "PAYPAL_SECRET" },
+        env: { type: "string", required: false, description: "live or sandbox (default sandbox)", env: "PAYPAL_ENV" },
+    });
+    rl.registerAction("payout.create", {
+        description: "Create a batch payout",
+        inputSchema: {
+            senderBatchId: { type: "string", required: true, description: "Unique batch ID" },
+            items: { type: "object", required: true, description: "Array of payout items [{receiver, amount: {value, currency}, recipient_type, note}]" },
+            emailSubject: { type: "string", required: false },
+            emailMessage: { type: "string", required: false },
+            note: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const header = { sender_batch_id: p.senderBatchId };
+            if (p.emailSubject)
+                header.email_subject = p.emailSubject;
+            if (p.emailMessage)
+                header.email_message = p.emailMessage;
+            if (p.note)
+                header.note = p.note;
+            return apiRequest(getConn(ctx), "POST", "/payments/payouts", { sender_batch_header: header, items: p.items });
+        },
+    });
+    rl.registerAction("payout.get", {
+        description: "Get a batch payout by ID (returns items)",
+        inputSchema: {
+            payoutBatchId: { type: "string", required: true },
+            limit: { type: "number", required: false, description: "Max items to return" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.limit)
+                qs.page_size = p.limit;
+            const data = (await apiRequest(getConn(ctx), "GET", `/payments/payouts/${p.payoutBatchId}`, undefined, qs));
+            return data.items;
+        },
+    });
+    rl.registerAction("payoutItem.get", {
+        description: "Get a payout item by ID",
+        inputSchema: { payoutItemId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { payoutItemId } = input;
+            return apiRequest(getConn(ctx), "GET", `/payments/payouts-item/${payoutItemId}`);
+        },
+    });
+    rl.registerAction("payoutItem.cancel", {
+        description: "Cancel an unclaimed payout item",
+        inputSchema: { payoutItemId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { payoutItemId } = input;
+            return apiRequest(getConn(ctx), "POST", `/payments/payouts-item/${payoutItemId}/cancel`);
+        },
+    });
+}

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

@@ -0,0 +1,35 @@
+const BASE = "https://api.peekalink.io";
+async function apiRequest(apiKey, endpoint, body) {
+    const res = await fetch(`${BASE}${endpoint}`, {
+        method: "POST",
+        headers: { "X-API-Key": apiKey, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Peekalink error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function peekalink(rl) {
+    rl.setName("peekalink");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Peekalink API key", env: "PEEKALINK_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("link.preview", {
+        description: "Get a rich preview for a URL",
+        inputSchema: { url: { type: "string", required: true, description: "URL to preview" } },
+        async execute(input, ctx) {
+            const { url } = input;
+            return apiRequest(key(ctx), "", { link: url });
+        },
+    });
+    rl.registerAction("link.isAvailable", {
+        description: "Check whether a preview is available for a URL",
+        inputSchema: { url: { type: "string", required: true, description: "URL to check" } },
+        async execute(input, ctx) {
+            const { url } = input;
+            return apiRequest(key(ctx), "/is-available/", { link: url });
+        },
+    });
+}

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

@@ -0,0 +1,94 @@
+const BASE = "https://api.phantombuster.com/api/v2";
+async function apiRequest(apiKey, 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: { "X-Phantombuster-Key": apiKey, "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(`Phantombuster error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function phantombuster(rl) {
+    rl.setName("phantombuster");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Phantombuster API key", env: "PHANTOMBUSTER_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("agent.delete", {
+        description: "Delete an agent",
+        inputSchema: { agentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { agentId } = input;
+            await apiRequest(key(ctx), "POST", "/agents/delete", { id: agentId });
+            return { success: true };
+        },
+    });
+    rl.registerAction("agent.get", {
+        description: "Get agent details",
+        inputSchema: { agentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { agentId } = input;
+            return apiRequest(key(ctx), "GET", "/agents/fetch", undefined, { id: agentId });
+        },
+    });
+    rl.registerAction("agent.getOutput", {
+        description: "Get the output of the last agent run",
+        inputSchema: {
+            agentId: { type: "string", required: true },
+            resolveData: { type: "boolean", required: false, description: "Resolve the result object (default false)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", "/agents/fetch-output", undefined, { id: p.agentId }));
+            if (p.resolveData) {
+                const result = (await apiRequest(key(ctx), "GET", "/containers/fetch-result-object", undefined, { id: data.containerId }));
+                if (!result.resultObject)
+                    return {};
+                return JSON.parse(result.resultObject);
+            }
+            return data;
+        },
+    });
+    rl.registerAction("agent.list", {
+        description: "List all agents",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const agents = (await apiRequest(key(ctx), "GET", "/agents/fetch-all"));
+            const limit = input?.limit;
+            if (limit)
+                return agents.slice(0, limit);
+            return agents;
+        },
+    });
+    rl.registerAction("agent.launch", {
+        description: "Launch an agent",
+        inputSchema: {
+            agentId: { type: "string", required: true },
+            arguments: { type: "object", required: false, description: "Arguments object to pass to the agent" },
+            bonusArgument: { type: "object", required: false, description: "Bonus argument object" },
+            resolveData: { type: "boolean", required: false, description: "Wait and return the container data (default false)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { id: p.agentId };
+            if (p.arguments)
+                body.arguments = p.arguments;
+            if (p.bonusArgument)
+                body.bonusArgument = p.bonusArgument;
+            const data = (await apiRequest(key(ctx), "POST", "/agents/launch", body));
+            if (p.resolveData) {
+                return apiRequest(key(ctx), "GET", "/containers/fetch", undefined, { id: data.containerId });
+            }
+            return data;
+        },
+    });
+}

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

@@ -0,0 +1,98 @@
+const BASE = "https://api.meethue.com/route";
+async function apiRequest(accessToken, method, path, body) {
+    const init = {
+        method,
+        headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(`${BASE}${path}`, init);
+    if (!res.ok)
+        throw new Error(`Philips Hue error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function philipsHue(rl) {
+    rl.setName("philipsHue");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Philips Hue OAuth2 access token", env: "PHILIPS_HUE_ACCESS_TOKEN" },
+        username: { type: "string", required: true, description: "Bridge username (whitelisted user ID)", env: "PHILIPS_HUE_USERNAME" },
+    });
+    function conn(ctx) {
+        return { token: ctx.connection.config.accessToken, user: ctx.connection.config.username };
+    }
+    rl.registerAction("light.get", {
+        description: "Get a light by ID",
+        inputSchema: { lightId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { lightId } = input;
+            const c = conn(ctx);
+            return apiRequest(c.token, "GET", `/api/${c.user}/lights/${lightId}`);
+        },
+    });
+    rl.registerAction("light.list", {
+        description: "List all lights",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            const data = (await apiRequest(c.token, "GET", `/api/${c.user}/lights`));
+            const lights = Object.entries(data).map(([id, v]) => ({ id, ...v }));
+            const limit = input?.limit;
+            if (limit)
+                return lights.slice(0, limit);
+            return lights;
+        },
+    });
+    rl.registerAction("light.update", {
+        description: "Update a light's state (on/off, brightness, color, etc.)",
+        inputSchema: {
+            lightId: { type: "string", required: true },
+            on: { type: "boolean", required: true, description: "Turn light on or off" },
+            bri: { type: "number", required: false, description: "Brightness (1-254)" },
+            hue: { type: "number", required: false, description: "Hue (0-65535)" },
+            sat: { type: "number", required: false, description: "Saturation (0-254)" },
+            ct: { type: "number", required: false, description: "Color temperature (153-500 mirek)" },
+            xy: { type: "string", required: false, description: "CIE color as 'x,y' (e.g. 0.5,0.5)" },
+            transitiontime: { type: "number", required: false, description: "Transition time in seconds" },
+            alert: { type: "string", required: false, description: "none, select, or lselect" },
+            effect: { type: "string", required: false, description: "none or colorloop" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const c = conn(ctx);
+            const body = { on: p.on };
+            if (p.bri !== undefined)
+                body.bri = p.bri;
+            if (p.hue !== undefined)
+                body.hue = p.hue;
+            if (p.sat !== undefined)
+                body.sat = p.sat;
+            if (p.ct !== undefined)
+                body.ct = p.ct;
+            if (p.xy)
+                body.xy = p.xy.split(",").map(Number);
+            if (p.transitiontime !== undefined)
+                body.transitiontime = p.transitiontime * 100;
+            if (p.alert)
+                body.alert = p.alert;
+            if (p.effect)
+                body.effect = p.effect;
+            const data = (await apiRequest(c.token, "PUT", `/api/${c.user}/lights/${p.lightId}/state`, body));
+            const result = {};
+            for (const item of data) {
+                if (item.success)
+                    Object.assign(result, item.success);
+            }
+            return result;
+        },
+    });
+    rl.registerAction("light.delete", {
+        description: "Delete a light from the bridge",
+        inputSchema: { lightId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { lightId } = input;
+            const c = conn(ctx);
+            return apiRequest(c.token, "DELETE", `/api/${c.user}/lights/${lightId}`);
+        },
+    });
+}