runline 0.1.0

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

@@ -0,0 +1,77 @@
+const BASE_URL = "https://api.medium.com/v1";
+async function apiRequest(token, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", Accept: "application/json", "Accept-Charset": "utf-8" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Medium API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function medium(rl) {
+    rl.setName("medium");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Medium integration token", env: "MEDIUM_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("post.create", {
+        description: "Create a post on Medium. Posts under the authenticated user by default, or under a publication if publicationId is provided.",
+        inputSchema: {
+            title: { type: "string", required: true, description: "Post title (max 100 chars)" },
+            contentFormat: { type: "string", required: true, description: "'html' or 'markdown'" },
+            content: { type: "string", required: true, description: "Post body in the specified format" },
+            publicationId: { type: "string", required: false, description: "Publication ID to post under (omit for personal post)" },
+            tags: { type: "array", required: false, description: "Array of tag strings (max 5, each max 25 chars)" },
+            canonicalUrl: { type: "string", required: false, description: "Original URL if cross-posting" },
+            publishStatus: { type: "string", required: false, description: "'public' (default), 'draft', or 'unlisted'" },
+            license: { type: "string", required: false, description: "License: all-rights-reserved, cc-40-by, cc-40-by-nc, cc-40-by-nc-nd, cc-40-by-nc-sa, cc-40-by-nd, cc-40-by-sa, cc-40-zero, public-domain" },
+            notifyFollowers: { type: "boolean", required: false, description: "Notify followers" },
+        },
+        async execute(input, ctx) {
+            const { title, contentFormat, content, publicationId, tags, canonicalUrl, publishStatus, license, notifyFollowers } = input;
+            const body = { title, contentFormat, content, tags: tags ?? [] };
+            if (canonicalUrl)
+                body.canonicalUrl = canonicalUrl;
+            if (publishStatus)
+                body.publishStatus = publishStatus;
+            if (license)
+                body.license = license;
+            if (notifyFollowers !== undefined)
+                body.notifyFollowers = notifyFollowers;
+            if (publicationId) {
+                const resp = (await apiRequest(tok(ctx), "POST", `/publications/${publicationId}/posts`, body));
+                return resp.data;
+            }
+            // Get authenticated user ID first
+            const me = (await apiRequest(tok(ctx), "GET", "/me"));
+            const authorId = me.data.id;
+            const resp = (await apiRequest(tok(ctx), "POST", `/users/${authorId}/posts`, body));
+            return resp.data;
+        },
+    });
+    rl.registerAction("publication.list", {
+        description: "List publications for the authenticated user",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const me = (await apiRequest(tok(ctx), "GET", "/me"));
+            const userId = me.data.id;
+            const resp = (await apiRequest(tok(ctx), "GET", `/users/${userId}/publications`));
+            let data = resp.data;
+            if (limit)
+                data = data.slice(0, limit);
+            return data;
+        },
+    });
+    rl.registerAction("me", {
+        description: "Get the authenticated user's profile",
+        async execute(_input, ctx) {
+            const resp = (await apiRequest(tok(ctx), "GET", "/me"));
+            return resp.data;
+        },
+    });
+}

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

@@ -0,0 +1,57 @@
+const BASE_URL = "https://rest.messagebird.com";
+async function apiRequest(accessKey, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: { Authorization: `AccessKey ${accessKey}`, Accept: "application/json", "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`MessageBird API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function messagebird(rl) {
+    rl.setName("messagebird");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessKey: { type: "string", required: true, description: "MessageBird access key", env: "MESSAGEBIRD_ACCESS_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.accessKey;
+    rl.registerAction("sms.send", {
+        description: "Send an SMS message",
+        inputSchema: {
+            originator: { type: "string", required: true, description: "Sender number or alphanumeric (max 11 chars)" },
+            recipients: { type: "string", required: true, description: "Comma-separated recipient phone numbers (international format)" },
+            body: { type: "string", required: true, description: "Message text" },
+            type: { type: "string", required: false, description: "sms (default), binary, or flash" },
+            datacoding: { type: "string", required: false, description: "auto, plain, or unicode" },
+            reference: { type: "string", required: false, description: "Client reference" },
+            reportUrl: { type: "string", required: false, description: "Status report webhook URL (requires reference)" },
+            validity: { type: "number", required: false, description: "Validity in seconds" },
+            gateway: { type: "number", required: false, description: "SMS route gateway" },
+            mclass: { type: "number", required: false, description: "0=normal, 1=flash" },
+            scheduledDatetime: { type: "string", required: false, description: "Scheduled send time (RFC3339)" },
+            groupIds: { type: "string", required: false, description: "Comma-separated group IDs (alternative to recipients)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                originator: p.originator,
+                body: p.body,
+                recipients: p.recipients.split(",").map((r) => Number.parseInt(r.trim(), 10)),
+            };
+            for (const k of ["type", "datacoding", "reference", "reportUrl", "validity", "gateway", "mclass", "scheduledDatetime", "groupIds"]) {
+                if (p[k] !== undefined && p[k] !== null)
+                    body[k] = p[k];
+            }
+            return apiRequest(key(ctx), "POST", "/messages", body);
+        },
+    });
+    rl.registerAction("balance.get", {
+        description: "Get current account balance",
+        async execute(_input, ctx) {
+            return apiRequest(key(ctx), "GET", "/balance");
+        },
+    });
+}

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

@@ -0,0 +1,130 @@
+async function apiRequest(baseUrl, sessionToken, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: { "X-Metabase-Session": sessionToken, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(`${baseUrl}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Metabase API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function metabase(rl) {
+    rl.setName("metabase");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Metabase instance URL (e.g. https://metabase.example.com)", env: "METABASE_URL" },
+        sessionToken: { type: "string", required: true, description: "Metabase session token (from POST /api/session)", env: "METABASE_SESSION_TOKEN" },
+    });
+    const conn = (ctx) => ({
+        baseUrl: ctx.connection.config.url.replace(/\/$/, ""),
+        token: ctx.connection.config.sessionToken,
+    });
+    // ── Question (Card) ─────────────────────────────────
+    rl.registerAction("question.get", {
+        description: "Get a specific question/card",
+        inputSchema: { questionId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/card/${input.questionId}`);
+        },
+    });
+    rl.registerAction("question.list", {
+        description: "List all questions/cards",
+        async execute(_input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", "/api/card/");
+        },
+    });
+    rl.registerAction("question.getResults", {
+        description: "Get the results of a question as JSON",
+        inputSchema: {
+            questionId: { type: "number", required: true },
+            format: { type: "string", required: false, description: "json (default), csv, xlsx — note: only json returns structured data" },
+        },
+        async execute(input, ctx) {
+            const { questionId, format = "json" } = input;
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "POST", `/api/card/${questionId}/query/${format}`);
+        },
+    });
+    // ── Alert ───────────────────────────────────────────
+    rl.registerAction("alert.get", {
+        description: "Get a specific alert",
+        inputSchema: { alertId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/alert/${input.alertId}`);
+        },
+    });
+    rl.registerAction("alert.list", {
+        description: "List all alerts",
+        async execute(_input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", "/api/alert/");
+        },
+    });
+    // ── Database ────────────────────────────────────────
+    rl.registerAction("database.list", {
+        description: "List all databases",
+        async execute(_input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            const data = (await apiRequest(baseUrl, token, "GET", "/api/database/"));
+            return data.data;
+        },
+    });
+    rl.registerAction("database.getFields", {
+        description: "Get fields from a database",
+        inputSchema: { databaseId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/database/${input.databaseId}/fields`);
+        },
+    });
+    rl.registerAction("database.add", {
+        description: "Add a new database/datasource",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Display name" },
+            engine: { type: "string", required: true, description: "postgres, mysql, h2, sqlite, mongo, redshift" },
+            host: { type: "string", required: false, description: "Database host (for postgres/mysql/mongo/redshift)" },
+            port: { type: "number", required: false, description: "Database port" },
+            user: { type: "string", required: false, description: "Database user" },
+            password: { type: "string", required: false, description: "Database password" },
+            dbName: { type: "string", required: false, description: "Database name or file path (for h2/sqlite)" },
+            isFullSync: { type: "boolean", required: false, description: "Full sync (default true)" },
+        },
+        async execute(input, ctx) {
+            const { name, engine, host, port, user, password, dbName, isFullSync = true } = input;
+            const { baseUrl, token } = conn(ctx);
+            const details = {};
+            if (host)
+                details.host = host;
+            if (port)
+                details.port = port;
+            if (user)
+                details.user = user;
+            if (password)
+                details.password = password;
+            if (dbName)
+                details.db = dbName;
+            return apiRequest(baseUrl, token, "POST", "/api/database", { name, engine, details, is_full_sync: isFullSync });
+        },
+    });
+    // ── Metric ──────────────────────────────────────────
+    rl.registerAction("metric.get", {
+        description: "Get a specific metric",
+        inputSchema: { metricId: { type: "number", required: true } },
+        async execute(input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", `/api/metric/${input.metricId}`);
+        },
+    });
+    rl.registerAction("metric.list", {
+        description: "List all metrics",
+        async execute(_input, ctx) {
+            const { baseUrl, token } = conn(ctx);
+            return apiRequest(baseUrl, token, "GET", "/api/metric/");
+        },
+    });
+}