runline 0.1.0

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

@@ -0,0 +1,65 @@
+const BASE = "https://api.pushover.net/1";
+export default function pushover(rl) {
+    rl.setName("pushover");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: { type: "string", required: true, description: "Pushover application API token", env: "PUSHOVER_API_TOKEN" },
+    });
+    const token = (ctx) => ctx.connection.config.apiToken;
+    rl.registerAction("message.push", {
+        description: "Send a push notification via Pushover",
+        inputSchema: {
+            userKey: { type: "string", required: true, description: "User or group key" },
+            message: { type: "string", required: true },
+            priority: { type: "number", required: false, description: "-2 (lowest) to 2 (emergency), default 0" },
+            title: { type: "string", required: false },
+            url: { type: "string", required: false, description: "Supplementary URL" },
+            urlTitle: { type: "string", required: false },
+            sound: { type: "string", required: false, description: "Sound name (e.g. pushover, bike, bugle)" },
+            device: { type: "string", required: false, description: "Target device name(s), comma-separated" },
+            html: { type: "boolean", required: false, description: "Enable HTML formatting" },
+            retry: { type: "number", required: false, description: "Retry interval in seconds (for priority 2, min 30)" },
+            expire: { type: "number", required: false, description: "Expiry in seconds (for priority 2, max 10800)" },
+            ttl: { type: "number", required: false, description: "Time to live in seconds" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                token: token(ctx),
+                user: p.userKey,
+                message: p.message,
+            };
+            if (p.priority !== undefined)
+                body.priority = p.priority;
+            if (p.title)
+                body.title = p.title;
+            if (p.url)
+                body.url = p.url;
+            if (p.urlTitle)
+                body.url_title = p.urlTitle;
+            if (p.sound)
+                body.sound = p.sound;
+            if (p.device)
+                body.device = p.device;
+            if (p.html)
+                body.html = 1;
+            if (p.retry)
+                body.retry = p.retry;
+            if (p.expire)
+                body.expire = p.expire;
+            if (p.ttl)
+                body.ttl = p.ttl;
+            const formBody = Object.entries(body)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+                .join("&");
+            const res = await fetch(`${BASE}/messages.json`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: formBody,
+            });
+            if (!res.ok)
+                throw new Error(`Pushover error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

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

@@ -0,0 +1,153 @@
+const BASE = "https://api.quickbase.com/v1";
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { hostname: c.hostname, userToken: c.userToken };
+}
+async function apiRequest(conn, method, endpoint, body, 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 init = {
+        method,
+        headers: {
+            "QB-Realm-Hostname": conn.hostname,
+            Authorization: `QB-USER-TOKEN ${conn.userToken}`,
+            "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(`QuickBase error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function quickbase(rl) {
+    rl.setName("quickbase");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        hostname: { type: "string", required: true, description: "QuickBase realm hostname (e.g. mycompany.quickbase.com)", env: "QUICKBASE_HOSTNAME" },
+        userToken: { type: "string", required: true, description: "QuickBase user token", env: "QUICKBASE_USER_TOKEN" },
+    });
+    rl.registerAction("field.list", {
+        description: "List all fields for a table",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(getConn(ctx), "GET", "/fields", undefined, { tableId: p.tableId }));
+            if (p.limit)
+                return data.slice(0, p.limit);
+            return data;
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file attachment",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            recordId: { type: "string", required: true },
+            fieldId: { type: "string", required: true },
+            versionNumber: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { tableId, recordId, fieldId, versionNumber } = input;
+            return apiRequest(getConn(ctx), "DELETE", `/files/${tableId}/${recordId}/${fieldId}/${versionNumber}`);
+        },
+    });
+    rl.registerAction("record.create", {
+        description: "Create records in a QuickBase table",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            data: { type: "object", required: true, description: "Array of record objects with field IDs as keys, e.g. [{\"6\": {\"value\": \"test\"}}]" },
+            fieldsToReturn: { type: "object", required: false, description: "Array of field IDs to return (default: [3])" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { to: p.tableId, data: p.data };
+            body.fieldsToReturn = p.fieldsToReturn ?? [3];
+            return apiRequest(getConn(ctx), "POST", "/records", body);
+        },
+    });
+    rl.registerAction("record.delete", {
+        description: "Delete records matching a query",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            where: { type: "string", required: true, description: "Query string, e.g. {3.EX.123}" },
+        },
+        async execute(input, ctx) {
+            const { tableId, where } = input;
+            return apiRequest(getConn(ctx), "DELETE", "/records", { from: tableId, where });
+        },
+    });
+    rl.registerAction("record.query", {
+        description: "Query records from a table",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            where: { type: "string", required: false, description: "Query string filter" },
+            select: { type: "object", required: false, description: "Array of field IDs to return" },
+            sortBy: { type: "object", required: false, description: "Array of sort objects [{fieldId, order: 'ASC'|'DESC'}]" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = { from: p.tableId };
+            if (p.where)
+                body.where = p.where;
+            if (p.select)
+                body.select = p.select;
+            if (p.sortBy)
+                body.sortBy = p.sortBy;
+            if (p.limit)
+                body.options = { top: p.limit };
+            return apiRequest(getConn(ctx), "POST", "/records/query", body);
+        },
+    });
+    rl.registerAction("record.upsert", {
+        description: "Create or update records (upsert) using a merge field",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            mergeFieldId: { type: "number", required: true, description: "Field ID used as the merge key" },
+            data: { type: "object", required: true, description: "Array of record objects" },
+            fieldsToReturn: { type: "object", required: false, description: "Array of field IDs to return" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { to: p.tableId, data: p.data, mergeFieldId: p.mergeFieldId };
+            body.fieldsToReturn = p.fieldsToReturn ?? [3];
+            return apiRequest(getConn(ctx), "POST", "/records", body);
+        },
+    });
+    rl.registerAction("report.get", {
+        description: "Get report metadata",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            reportId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { tableId, reportId } = input;
+            return apiRequest(getConn(ctx), "GET", `/reports/${reportId}`, undefined, { tableId });
+        },
+    });
+    rl.registerAction("report.run", {
+        description: "Run a report and get results",
+        inputSchema: {
+            tableId: { type: "string", required: true },
+            reportId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { tableId: p.tableId };
+            if (p.limit)
+                qs.top = p.limit;
+            return apiRequest(getConn(ctx), "POST", `/reports/${p.reportId}/run`, {}, qs);
+        },
+    });
+}

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

@@ -0,0 +1,73 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const sandbox = c.sandbox === true;
+    const base = sandbox ? "https://sandbox-quickbooks.api.intuit.com" : "https://quickbooks.api.intuit.com";
+    return { base, accessToken: c.accessToken, companyId: c.companyId };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.base}${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 ${conn.accessToken}`, 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(`QuickBooks error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function capitalCase(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
+function registerQbResource(rl, resource, conn) {
+    const cap = capitalCase(resource);
+    const prefix = (c) => `/v3/company/${c.companyId}`;
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: { data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            return api(c, "POST", `${prefix(c)}/${resource}`, input.data);
+        } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource} by ID`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            const data = (await api(c, "GET", `${prefix(c)}/${resource}/${input.id}`));
+            return data[cap];
+        } });
+    rl.registerAction(`${resource}.query`, { description: `Query ${resource}s (SQL-like)`, inputSchema: { query: { type: "string", required: false, description: `WHERE clause (default: SELECT * FROM ${cap})` }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            const p = (input ?? {});
+            let q = `SELECT * FROM ${cap}`;
+            if (p.query)
+                q += ` ${p.query}`;
+            if (p.limit)
+                q += ` MAXRESULTS ${p.limit}`;
+            const data = (await api(c, "GET", `${prefix(c)}/query`, undefined, { query: q }));
+            return data.QueryResponse?.[cap] ?? [];
+        } });
+    rl.registerAction(`${resource}.update`, { description: `Update a ${resource} (must include Id and SyncToken)`, inputSchema: { data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            return api(c, "POST", `${prefix(c)}/${resource}`, input.data);
+        } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true }, syncToken: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const c = conn(ctx);
+            const p = input;
+            return api(c, "POST", `${prefix(c)}/${resource}`, { Id: p.id, SyncToken: p.syncToken }, { operation: "delete" });
+        } });
+}
+export default function quickbooks(rl) {
+    rl.setName("quickbooks");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "QuickBooks OAuth2 access token", env: "QUICKBOOKS_ACCESS_TOKEN" },
+        companyId: { type: "string", required: true, description: "QuickBooks Company/Realm ID", env: "QUICKBOOKS_COMPANY_ID" },
+        sandbox: { type: "boolean", required: false, description: "Use sandbox environment", env: "QUICKBOOKS_SANDBOX" },
+    });
+    for (const resource of ["bill", "customer", "employee", "estimate", "invoice", "item", "payment", "purchase", "vendor"]) {
+        registerQbResource(rl, resource, getConn);
+    }
+}

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

@@ -0,0 +1,36 @@
+export default function quickchart(rl) {
+    rl.setName("quickchart");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({});
+    rl.registerAction("chart.create", {
+        description: "Generate a chart image URL via QuickChart.io (no auth required)",
+        inputSchema: {
+            type: { type: "string", required: true, description: "Chart type: bar, line, pie, doughnut, radar, scatter, etc." },
+            labels: { type: "object", required: true, description: "Array of label strings" },
+            datasets: { type: "object", required: true, description: "Array of dataset objects [{label, data: [...], backgroundColor?, borderColor?}]" },
+            width: { type: "number", required: false, description: "Chart width in pixels (default 500)" },
+            height: { type: "number", required: false, description: "Chart height in pixels (default 300)" },
+            backgroundColor: { type: "string", required: false, description: "Chart background color" },
+            format: { type: "string", required: false, description: "Output format: png (default), svg, webp, pdf" },
+        },
+        async execute(input) {
+            const p = (input ?? {});
+            const chart = {
+                type: p.type,
+                data: { labels: p.labels, datasets: p.datasets },
+            };
+            const qs = new URLSearchParams();
+            qs.set("chart", JSON.stringify(chart));
+            if (p.width)
+                qs.set("width", String(p.width));
+            if (p.height)
+                qs.set("height", String(p.height));
+            if (p.backgroundColor)
+                qs.set("backgroundColor", p.backgroundColor);
+            if (p.format)
+                qs.set("format", p.format);
+            const url = `https://quickchart.io/chart?${qs.toString()}`;
+            return { url, chart };
+        },
+    });
+}

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

@@ -0,0 +1,209 @@
+const BASE = "https://api.raindrop.io/rest/v1";
+async function apiRequest(token, method, endpoint, body) {
+    const init = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(`${BASE}${endpoint}`, init);
+    if (!res.ok)
+        throw new Error(`Raindrop error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function raindrop(rl) {
+    rl.setName("raindrop");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Raindrop.io access token", env: "RAINDROP_ACCESS_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    // ── Bookmark ────────────────────────────────────────
+    rl.registerAction("bookmark.create", {
+        description: "Create a bookmark (raindrop)",
+        inputSchema: {
+            link: { type: "string", required: true, description: "URL to bookmark" },
+            collectionId: { type: "string", required: true },
+            title: { type: "string", required: false },
+            tags: { type: "string", required: false, description: "Comma-separated tags" },
+            pleaseParse: { type: "boolean", required: false, description: "Auto-parse page metadata" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { link: p.link, collection: { $id: Number(p.collectionId) } };
+            if (p.title)
+                body.title = p.title;
+            if (p.tags)
+                body.tags = p.tags.split(",").map(t => t.trim());
+            if (p.pleaseParse)
+                body.pleaseParse = {};
+            const data = (await apiRequest(key(ctx), "POST", "/raindrop", body));
+            return data.item;
+        },
+    });
+    rl.registerAction("bookmark.get", {
+        description: "Get a bookmark by ID",
+        inputSchema: { bookmarkId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { bookmarkId } = input;
+            const data = (await apiRequest(key(ctx), "GET", `/raindrop/${bookmarkId}`));
+            return data.item;
+        },
+    });
+    rl.registerAction("bookmark.list", {
+        description: "List bookmarks in a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "GET", `/raindrops/${p.collectionId}`));
+            let items = (data.items ?? []);
+            if (p.limit)
+                items = items.slice(0, p.limit);
+            return items;
+        },
+    });
+    rl.registerAction("bookmark.update", {
+        description: "Update a bookmark",
+        inputSchema: {
+            bookmarkId: { type: "string", required: true },
+            title: { type: "string", required: false },
+            link: { type: "string", required: false },
+            tags: { type: "string", required: false, description: "Comma-separated tags" },
+            collectionId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {};
+            if (p.title)
+                body.title = p.title;
+            if (p.link)
+                body.link = p.link;
+            if (p.tags)
+                body.tags = p.tags.split(",").map(t => t.trim());
+            if (p.collectionId)
+                body.collection = { $id: Number(p.collectionId) };
+            const data = (await apiRequest(key(ctx), "PUT", `/raindrop/${p.bookmarkId}`, body));
+            return data.item;
+        },
+    });
+    rl.registerAction("bookmark.delete", {
+        description: "Delete a bookmark",
+        inputSchema: { bookmarkId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { bookmarkId } = input;
+            return apiRequest(key(ctx), "DELETE", `/raindrop/${bookmarkId}`);
+        },
+    });
+    // ── Collection ──────────────────────────────────────
+    rl.registerAction("collection.create", {
+        description: "Create a collection",
+        inputSchema: {
+            title: { type: "string", required: true },
+            parentId: { type: "string", required: false, description: "Parent collection ID" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { title: p.title };
+            if (p.parentId)
+                body["parent.$id"] = Number(p.parentId);
+            const data = (await apiRequest(key(ctx), "POST", "/collection", body));
+            return data.item;
+        },
+    });
+    rl.registerAction("collection.get", {
+        description: "Get a collection by ID",
+        inputSchema: { collectionId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { collectionId } = input;
+            const data = (await apiRequest(key(ctx), "GET", `/collection/${collectionId}`));
+            return data.item;
+        },
+    });
+    rl.registerAction("collection.list", {
+        description: "List collections",
+        inputSchema: {
+            type: { type: "string", required: false, description: "parent (default) or children" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const endpoint = p.type === "children" ? "/collections/childrens" : "/collections";
+            const data = (await apiRequest(key(ctx), "GET", endpoint));
+            let items = (data.items ?? []);
+            if (p.limit)
+                items = items.slice(0, p.limit);
+            return items;
+        },
+    });
+    rl.registerAction("collection.update", {
+        description: "Update a collection",
+        inputSchema: {
+            collectionId: { type: "string", required: true },
+            title: { type: "string", required: false },
+            parentId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {};
+            if (p.title)
+                body.title = p.title;
+            if (p.parentId)
+                body["parent.$id"] = Number(p.parentId);
+            const data = (await apiRequest(key(ctx), "PUT", `/collection/${p.collectionId}`, body));
+            return data.item;
+        },
+    });
+    rl.registerAction("collection.delete", {
+        description: "Delete a collection",
+        inputSchema: { collectionId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { collectionId } = input;
+            return apiRequest(key(ctx), "DELETE", `/collection/${collectionId}`);
+        },
+    });
+    // ── Tag ─────────────────────────────────────────────
+    rl.registerAction("tag.list", {
+        description: "List tags (optionally filtered by collection)",
+        inputSchema: {
+            collectionId: { type: "string", required: false },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const endpoint = p.collectionId ? `/tags/${p.collectionId}` : "/tags";
+            const data = (await apiRequest(key(ctx), "GET", endpoint));
+            let items = (data.items ?? []);
+            if (p.limit)
+                items = items.slice(0, p.limit);
+            return items;
+        },
+    });
+    rl.registerAction("tag.delete", {
+        description: "Delete tags",
+        inputSchema: {
+            tags: { type: "string", required: true, description: "Comma-separated tag names to delete" },
+            collectionId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const endpoint = p.collectionId ? `/tags/${p.collectionId}` : "/tags";
+            return apiRequest(key(ctx), "DELETE", endpoint, { tags: p.tags.split(",").map(t => t.trim()) });
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get user info (self or by ID)",
+        inputSchema: {
+            userId: { type: "string", required: false, description: "User ID (omit for self)" },
+        },
+        async execute(input, ctx) {
+            const userId = input?.userId;
+            const endpoint = userId ? `/user/${userId}` : "/user";
+            const data = (await apiRequest(key(ctx), "GET", endpoint));
+            return data.user;
+        },
+    });
+}