runline 0.1.0

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

@@ -0,0 +1,145 @@
+const BASE_URL = "https://mandrillapp.com/api/1.0";
+async function apiRequest(apiKey, endpoint, body = {}) {
+    body.key = apiKey;
+    const res = await fetch(`${BASE_URL}${endpoint}.json`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Mandrill API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function mandrill(rl) {
+    rl.setName("mandrill");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Mandrill API key", env: "MANDRILL_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    function buildMessage(p) {
+        const message = {
+            from_email: p.fromEmail,
+            to: p.toEmail.split(",").map((e) => ({ email: e.trim(), type: "to" })),
+        };
+        if (p.fromName)
+            message.from_name = p.fromName;
+        if (p.subject)
+            message.subject = p.subject;
+        if (p.html)
+            message.html = p.html;
+        if (p.text)
+            message.text = p.text;
+        if (p.bccAddress)
+            message.bcc_address = p.bccAddress;
+        if (p.tags)
+            message.tags = p.tags.split(",").map((t) => t.trim());
+        if (p.subaccount)
+            message.subaccount = p.subaccount;
+        if (p.trackOpens !== undefined)
+            message.track_opens = p.trackOpens;
+        if (p.trackClicks !== undefined)
+            message.track_clicks = p.trackClicks;
+        if (p.autoText !== undefined)
+            message.auto_text = p.autoText;
+        if (p.autoHtml !== undefined)
+            message.auto_html = p.autoHtml;
+        if (p.inlineCss !== undefined)
+            message.inline_css = p.inlineCss;
+        if (p.important !== undefined)
+            message.important = p.important;
+        if (p.preserveRecipients !== undefined)
+            message.preserve_recipients = p.preserveRecipients;
+        if (p.urlStripQs !== undefined)
+            message.url_strip_qs = p.urlStripQs;
+        if (p.viewContentLink !== undefined)
+            message.view_content_link = p.viewContentLink;
+        if (p.async !== undefined)
+            message.async = p.async;
+        if (p.ipPool)
+            message.ip_pool = p.ipPool;
+        if (p.trackingDomain)
+            message.tracking_domain = p.trackingDomain;
+        if (p.signingDomain)
+            message.signing_domain = p.signingDomain;
+        if (p.returnPathDomain)
+            message.return_path_domain = p.returnPathDomain;
+        if (p.googleAnalyticsCampaign)
+            message.google_analytics_campaign = p.googleAnalyticsCampaign;
+        if (p.googleAnalyticsDomains)
+            message.google_analytics_domains = p.googleAnalyticsDomains.split(",").map((d) => d.trim());
+        if (p.mergeVars)
+            message.global_merge_vars = p.mergeVars;
+        if (p.metadata)
+            message.metadata = p.metadata;
+        if (p.headers)
+            message.headers = p.headers;
+        if (p.attachments)
+            message.attachments = p.attachments;
+        return message;
+    }
+    const messageInputSchema = {
+        fromEmail: { type: "string", required: true },
+        toEmail: { type: "string", required: true, description: "Comma-separated recipient emails" },
+        fromName: { type: "string", required: false },
+        subject: { type: "string", required: false },
+        html: { type: "string", required: false, description: "HTML body" },
+        text: { type: "string", required: false, description: "Plain text body" },
+        bccAddress: { type: "string", required: false },
+        tags: { type: "string", required: false, description: "Comma-separated tags" },
+        subaccount: { type: "string", required: false },
+        trackOpens: { type: "boolean", required: false },
+        trackClicks: { type: "boolean", required: false },
+        autoText: { type: "boolean", required: false },
+        autoHtml: { type: "boolean", required: false },
+        inlineCss: { type: "boolean", required: false },
+        important: { type: "boolean", required: false },
+        preserveRecipients: { type: "boolean", required: false },
+        urlStripQs: { type: "boolean", required: false },
+        viewContentLink: { type: "boolean", required: false },
+        async: { type: "boolean", required: false },
+        ipPool: { type: "string", required: false },
+        trackingDomain: { type: "string", required: false },
+        signingDomain: { type: "string", required: false },
+        returnPathDomain: { type: "string", required: false },
+        googleAnalyticsCampaign: { type: "string", required: false },
+        googleAnalyticsDomains: { type: "string", required: false, description: "Comma-separated domains" },
+        mergeVars: { type: "array", required: false, description: "Array of {name, content} objects" },
+        metadata: { type: "object", required: false, description: "Key-value metadata" },
+        headers: { type: "object", required: false, description: "Extra headers" },
+        attachments: { type: "array", required: false, description: "Array of {type, name, content} (content is base64)" },
+        sendAt: { type: "string", required: false, description: "UTC datetime YYYY-MM-DD HH:mm:ss" },
+    };
+    rl.registerAction("message.sendHtml", {
+        description: "Send an email with HTML/text content via Mandrill",
+        inputSchema: messageInputSchema,
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                message: buildMessage(p),
+                template_content: [],
+            };
+            if (p.sendAt)
+                body.send_at = p.sendAt;
+            return apiRequest(key(ctx), "/messages/send", body);
+        },
+    });
+    rl.registerAction("message.sendTemplate", {
+        description: "Send an email using a Mandrill template",
+        inputSchema: {
+            templateName: { type: "string", required: true, description: "Template slug" },
+            ...messageInputSchema,
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                template_name: p.templateName,
+                template_content: [],
+                message: buildMessage(p),
+            };
+            if (p.sendAt)
+                body.send_at = p.sendAt;
+            return apiRequest(key(ctx), "/messages/send-template", body);
+        },
+    });
+}

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

@@ -0,0 +1,97 @@
+async function apiRequest(apiKey, useHttps, method, endpoint, qs = {}) {
+    const protocol = useHttps ? "https" : "http";
+    const url = new URL(`${protocol}://api.marketstack.com/v1${endpoint}`);
+    url.searchParams.set("access_key", apiKey);
+    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(), { method });
+    if (!res.ok)
+        throw new Error(`Marketstack API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginateAll(apiKey, useHttps, endpoint, qs = {}, limit) {
+    const all = [];
+    qs.offset = 0;
+    let resp;
+    do {
+        resp = (await apiRequest(apiKey, useHttps, "GET", endpoint, qs));
+        const data = resp.data;
+        if (data)
+            all.push(...data);
+        if (limit && all.length >= limit)
+            return all.slice(0, limit);
+        qs.offset += resp.count ?? 0;
+    } while (resp.total > all.length);
+    return all;
+}
+export default function marketstack(rl) {
+    rl.setName("marketstack");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Marketstack API access key", env: "MARKETSTACK_API_KEY" },
+        useHttps: { type: "boolean", required: false, description: "Use HTTPS (requires paid plan). Default: false", default: false },
+    });
+    const conn = (ctx) => ({
+        apiKey: ctx.connection.config.apiKey,
+        useHttps: ctx.connection.config.useHttps ?? false,
+    });
+    // ── End-of-Day Data ─────────────────────────────────
+    rl.registerAction("endOfDayData.list", {
+        description: "Get end-of-day stock market closing data. Must specify exactly one of: latest, specificDate, or dateFrom+dateTo.",
+        inputSchema: {
+            symbols: { type: "string", required: true, description: "Comma-separated stock symbols (e.g. AAPL,MSFT)" },
+            latest: { type: "boolean", required: false, description: "Get latest EOD data" },
+            specificDate: { type: "string", required: false, description: "Specific date (YYYY-MM-DD)" },
+            dateFrom: { type: "string", required: false, description: "Start date (YYYY-MM-DD)" },
+            dateTo: { type: "string", required: false, description: "End date (YYYY-MM-DD)" },
+            sort: { type: "string", required: false, description: "ASC or DESC" },
+            exchange: { type: "string", required: false, description: "Filter by exchange MIC" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const { apiKey, useHttps } = conn(ctx);
+            const qs = { symbols: p.symbols };
+            if (p.sort)
+                qs.sort = p.sort;
+            if (p.exchange)
+                qs.exchange = p.exchange;
+            let endpoint;
+            if (p.latest) {
+                endpoint = "/eod/latest";
+            }
+            else if (p.specificDate) {
+                endpoint = `/eod/${p.specificDate.split("T")[0]}`;
+            }
+            else if (p.dateFrom && p.dateTo) {
+                endpoint = "/eod";
+                qs.date_from = p.dateFrom.split("T")[0];
+                qs.date_to = p.dateTo.split("T")[0];
+            }
+            else {
+                throw new Error("Specify one of: latest (true), specificDate, or dateFrom+dateTo");
+            }
+            return paginateAll(apiKey, useHttps, endpoint, qs, p.limit);
+        },
+    });
+    // ── Exchange ────────────────────────────────────────
+    rl.registerAction("exchange.get", {
+        description: "Get details about a stock exchange",
+        inputSchema: { exchange: { type: "string", required: true, description: "Exchange MIC code (e.g. XNAS)" } },
+        async execute(input, ctx) {
+            const { apiKey, useHttps } = conn(ctx);
+            return apiRequest(apiKey, useHttps, "GET", `/exchanges/${input.exchange}`);
+        },
+    });
+    // ── Ticker ──────────────────────────────────────────
+    rl.registerAction("ticker.get", {
+        description: "Get details about a stock ticker symbol",
+        inputSchema: { symbol: { type: "string", required: true, description: "Ticker symbol (e.g. AAPL)" } },
+        async execute(input, ctx) {
+            const { apiKey, useHttps } = conn(ctx);
+            return apiRequest(apiKey, useHttps, "GET", `/tickers/${input.symbol}`);
+        },
+    });
+}

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

@@ -0,0 +1,194 @@
+async function apiRequest(homeserver, token, method, endpoint, body, qs) {
+    const url = new URL(`${homeserver}/_matrix/client/r0${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null && v !== "")
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" },
+    };
+    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(`Matrix API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function generateTxnId() {
+    return crypto.randomUUID();
+}
+export default function matrix(rl) {
+    rl.setName("matrix");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        homeserverUrl: { type: "string", required: true, description: "Matrix homeserver URL (e.g. https://matrix.org)", env: "MATRIX_HOMESERVER_URL" },
+        accessToken: { type: "string", required: true, description: "Matrix access token", env: "MATRIX_ACCESS_TOKEN" },
+    });
+    const conn = (ctx) => ({
+        homeserver: ctx.connection.config.homeserverUrl.replace(/\/$/, ""),
+        token: ctx.connection.config.accessToken,
+    });
+    // ── Account ─────────────────────────────────────────
+    rl.registerAction("account.me", {
+        description: "Get info about the authenticated user",
+        async execute(_input, ctx) {
+            const { homeserver, token } = conn(ctx);
+            return apiRequest(homeserver, token, "GET", "/account/whoami");
+        },
+    });
+    // ── Room ────────────────────────────────────────────
+    rl.registerAction("room.create", {
+        description: "Create a new room",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Room name" },
+            preset: { type: "string", required: true, description: "private_chat, public_chat, or trusted_private_chat" },
+            roomAlias: { type: "string", required: false, description: "Local part of room alias (without # or :server)" },
+        },
+        async execute(input, ctx) {
+            const { name, preset, roomAlias } = input;
+            const { homeserver, token } = conn(ctx);
+            const body = { name, preset };
+            if (roomAlias)
+                body.room_alias_name = roomAlias;
+            return apiRequest(homeserver, token, "POST", "/createRoom", body);
+        },
+    });
+    rl.registerAction("room.join", {
+        description: "Join a room",
+        inputSchema: { roomIdOrAlias: { type: "string", required: true, description: "Room ID (!xxx:server) or alias (#xxx:server)" } },
+        async execute(input, ctx) {
+            const { homeserver, token } = conn(ctx);
+            return apiRequest(homeserver, token, "POST", `/rooms/${encodeURIComponent(input.roomIdOrAlias)}/join`);
+        },
+    });
+    rl.registerAction("room.leave", {
+        description: "Leave a room",
+        inputSchema: { roomId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { homeserver, token } = conn(ctx);
+            return apiRequest(homeserver, token, "POST", `/rooms/${encodeURIComponent(input.roomId)}/leave`);
+        },
+    });
+    rl.registerAction("room.invite", {
+        description: "Invite a user to a room",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            userId: { type: "string", required: true, description: "Matrix user ID (@user:server)" },
+        },
+        async execute(input, ctx) {
+            const { roomId, userId } = input;
+            const { homeserver, token } = conn(ctx);
+            return apiRequest(homeserver, token, "POST", `/rooms/${encodeURIComponent(roomId)}/invite`, { user_id: userId });
+        },
+    });
+    rl.registerAction("room.kick", {
+        description: "Kick a user from a room",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            userId: { type: "string", required: true },
+            reason: { type: "string", required: false, description: "Reason for kicking" },
+        },
+        async execute(input, ctx) {
+            const { roomId, userId, reason } = input;
+            const { homeserver, token } = conn(ctx);
+            const body = { user_id: userId };
+            if (reason)
+                body.reason = reason;
+            return apiRequest(homeserver, token, "POST", `/rooms/${encodeURIComponent(roomId)}/kick`, body);
+        },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.create", {
+        description: "Send a message to a room",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            text: { type: "string", required: true, description: "Message text (or HTML if format is org.matrix.custom.html)" },
+            messageType: { type: "string", required: false, description: "m.text (default), m.notice, m.emote" },
+            messageFormat: { type: "string", required: false, description: "org.matrix.custom.html for HTML messages" },
+            fallbackText: { type: "string", required: false, description: "Plain text fallback for HTML messages" },
+        },
+        async execute(input, ctx) {
+            const { roomId, text, messageType = "m.text", messageFormat, fallbackText } = input;
+            const { homeserver, token } = conn(ctx);
+            const body = { msgtype: messageType, body: text };
+            if (messageFormat === "org.matrix.custom.html") {
+                body.format = messageFormat;
+                body.formatted_body = text;
+                body.body = fallbackText || text;
+            }
+            const txnId = generateTxnId();
+            return apiRequest(homeserver, token, "PUT", `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, body);
+        },
+    });
+    rl.registerAction("message.list", {
+        description: "Get messages from a room (newest first)",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            limit: { type: "number", required: false, description: "Max messages to return" },
+            filter: { type: "string", required: false, description: "JSON filter string" },
+        },
+        async execute(input, ctx) {
+            const { roomId, limit, filter } = (input ?? {});
+            const { homeserver, token } = conn(ctx);
+            if (limit) {
+                const qs = { dir: "b", limit };
+                if (filter)
+                    qs.filter = filter;
+                const data = (await apiRequest(homeserver, token, "GET", `/rooms/${encodeURIComponent(roomId)}/messages`, undefined, qs));
+                return data.chunk;
+            }
+            // Paginate all
+            const all = [];
+            let from;
+            let chunk;
+            do {
+                const qs = { dir: "b" };
+                if (from)
+                    qs.from = from;
+                if (filter)
+                    qs.filter = filter;
+                const data = (await apiRequest(homeserver, token, "GET", `/rooms/${encodeURIComponent(roomId)}/messages`, undefined, qs));
+                chunk = data.chunk;
+                all.push(...chunk);
+                from = data.end;
+            } while (chunk.length > 0);
+            return all;
+        },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.get", {
+        description: "Get a single event from a room",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            eventId: { type: "string", required: true, description: "Event ID ($xxx)" },
+        },
+        async execute(input, ctx) {
+            const { roomId, eventId } = input;
+            const { homeserver, token } = conn(ctx);
+            return apiRequest(homeserver, token, "GET", `/rooms/${encodeURIComponent(roomId)}/event/${encodeURIComponent(eventId)}`);
+        },
+    });
+    // ── Room Member ─────────────────────────────────────
+    rl.registerAction("roomMember.list", {
+        description: "List members of a room",
+        inputSchema: {
+            roomId: { type: "string", required: true },
+            membership: { type: "string", required: false, description: "Filter: join, invite, leave, ban, knock" },
+            notMembership: { type: "string", required: false, description: "Exclude membership type" },
+        },
+        async execute(input, ctx) {
+            const { roomId, membership, notMembership } = (input ?? {});
+            const { homeserver, token } = conn(ctx);
+            const qs = {};
+            if (membership)
+                qs.membership = membership;
+            if (notMembership)
+                qs.not_membership = notMembership;
+            const data = (await apiRequest(homeserver, token, "GET", `/rooms/${encodeURIComponent(roomId)}/members`, undefined, qs));
+            return data.chunk;
+        },
+    });
+}