runline 0.1.0

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

@@ -0,0 +1,185 @@
+async function apiRequest(token, method, endpoint, qs) {
+    const base = token ? "https://oauth.reddit.com" : "https://www.reddit.com";
+    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));
+        }
+    }
+    url.searchParams.set("api_type", "json");
+    const headers = { "User-Agent": "runline" };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const init = { method, headers };
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Reddit error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+export default function reddit(rl) {
+    rl.setName("reddit");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: false, description: "Reddit OAuth2 access token (required for post/comment/profile actions)", env: "REDDIT_ACCESS_TOKEN" },
+    });
+    // ── Post ────────────────────────────────────────────
+    rl.registerAction("post.create", {
+        description: "Submit a new post to a subreddit (requires auth)",
+        inputSchema: {
+            subreddit: { type: "string", required: true },
+            title: { type: "string", required: true },
+            kind: { type: "string", required: true, description: "self (text) or link" },
+            text: { type: "string", required: false, description: "Post body (for self posts)" },
+            url: { type: "string", required: false, description: "URL (for link posts)" },
+            resubmit: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { title: p.title, sr: p.subreddit, kind: p.kind };
+            if (p.kind === "self")
+                qs.text = p.text;
+            else
+                qs.url = p.url;
+            if (p.resubmit)
+                qs.resubmit = "true";
+            const data = (await apiRequest(getToken(ctx), "POST", "api/submit", qs));
+            return data.json?.data;
+        },
+    });
+    rl.registerAction("post.get", {
+        description: "Get a post by ID",
+        inputSchema: {
+            subreddit: { type: "string", required: true },
+            postId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { subreddit, postId } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `r/${subreddit}/comments/${postId}.json`));
+            const listing = data[0];
+            const ld = listing.data;
+            const children = ld.children;
+            return children[0]?.data;
+        },
+    });
+    rl.registerAction("post.list", {
+        description: "List posts from a subreddit (no auth required for public subreddits)",
+        inputSchema: {
+            subreddit: { type: "string", required: true },
+            category: { type: "string", required: false, description: "hot (default), new, rising, top, controversial" },
+            limit: { type: "number", required: false, description: "Max results (default 25)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const cat = p.category ?? "";
+            const endpoint = cat ? `r/${p.subreddit}/${cat}.json` : `r/${p.subreddit}.json`;
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            const data = (await apiRequest(getToken(ctx), "GET", endpoint, qs));
+            const ld = data.data;
+            return ld.children.map(c => c.data);
+        },
+    });
+    rl.registerAction("post.delete", {
+        description: "Delete a post (requires auth)",
+        inputSchema: { postId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { postId } = input;
+            await apiRequest(getToken(ctx), "POST", "api/del", { id: `t3_${postId}` });
+            return { success: true };
+        },
+    });
+    rl.registerAction("post.search", {
+        description: "Search posts",
+        inputSchema: {
+            keyword: { type: "string", required: true },
+            subreddit: { type: "string", required: false, description: "Limit search to subreddit" },
+            sort: { type: "string", required: false, description: "relevance, hot, top, new, comments" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { q: p.keyword };
+            if (p.sort)
+                qs.sort = p.sort;
+            if (p.limit)
+                qs.limit = p.limit;
+            const endpoint = p.subreddit ? `r/${p.subreddit}/search.json` : "search.json";
+            if (p.subreddit)
+                qs.restrict_sr = "true";
+            const data = (await apiRequest(getToken(ctx), "GET", endpoint, qs));
+            const ld = data.data;
+            return ld.children.map(c => c.data);
+        },
+    });
+    // ── Comment ─────────────────────────────────────────
+    rl.registerAction("comment.create", {
+        description: "Add a comment to a post (requires auth)",
+        inputSchema: {
+            postId: { type: "string", required: true },
+            text: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { postId, text } = input;
+            const data = (await apiRequest(getToken(ctx), "POST", "api/comment", { thing_id: `t3_${postId}`, text }));
+            const json = data.json;
+            const jd = json.data;
+            const things = jd.things;
+            return things[0]?.data;
+        },
+    });
+    rl.registerAction("comment.reply", {
+        description: "Reply to a comment (requires auth)",
+        inputSchema: {
+            commentId: { type: "string", required: true },
+            text: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const { commentId, text } = input;
+            const data = (await apiRequest(getToken(ctx), "POST", "api/comment", { thing_id: `t1_${commentId}`, text }));
+            const json = data.json;
+            const jd = json.data;
+            const things = jd.things;
+            return things[0]?.data;
+        },
+    });
+    rl.registerAction("comment.delete", {
+        description: "Delete a comment (requires auth)",
+        inputSchema: { commentId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { commentId } = input;
+            await apiRequest(getToken(ctx), "POST", "api/del", { id: `t1_${commentId}` });
+            return { success: true };
+        },
+    });
+    // ── Subreddit ───────────────────────────────────────
+    rl.registerAction("subreddit.get", {
+        description: "Get subreddit info or rules (no auth required)",
+        inputSchema: {
+            subreddit: { type: "string", required: true },
+            content: { type: "string", required: false, description: "about (default) or rules" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const content = p.content ?? "about";
+            const data = (await apiRequest(getToken(ctx), "GET", `r/${p.subreddit}/about/${content}.json`));
+            if (content === "rules")
+                return data.rules;
+            return data.data;
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get user profile info (no auth required)",
+        inputSchema: { username: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { username } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `user/${username}/about.json`));
+            return data.data;
+        },
+    });
+}

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

@@ -0,0 +1,53 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return {
+        domain: c.domain.replace(/\/$/, ""),
+        userId: c.userId,
+        authToken: c.authToken,
+    };
+}
+export default function rocketchat(rl) {
+    rl.setName("rocketchat");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        domain: { type: "string", required: true, description: "Rocket.Chat server URL (e.g. https://chat.example.com)", env: "ROCKETCHAT_DOMAIN" },
+        userId: { type: "string", required: true, description: "User ID", env: "ROCKETCHAT_USER_ID" },
+        authToken: { type: "string", required: true, description: "Auth token", env: "ROCKETCHAT_AUTH_TOKEN" },
+    });
+    rl.registerAction("chat.postMessage", {
+        description: "Post a message to a Rocket.Chat channel or DM",
+        inputSchema: {
+            channel: { type: "string", required: true, description: "Channel name with prefix (e.g. #general or @username)" },
+            text: { type: "string", required: true },
+            alias: { type: "string", required: false, description: "Display name alias" },
+            emoji: { type: "string", required: false, description: "Emoji avatar (e.g. :smile:)" },
+            avatar: { type: "string", required: false, description: "Avatar image URL" },
+            attachments: { type: "object", required: false, description: "Array of attachment objects" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const conn = getConn(ctx);
+            const body = { channel: p.channel, text: p.text };
+            if (p.alias)
+                body.alias = p.alias;
+            if (p.emoji)
+                body.emoji = p.emoji;
+            if (p.avatar)
+                body.avatar = p.avatar;
+            if (p.attachments)
+                body.attachments = p.attachments;
+            const res = await fetch(`${conn.domain}/api/v1/chat.postMessage`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Auth-Token": conn.authToken,
+                    "X-User-Id": conn.userId,
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`Rocket.Chat error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

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

@@ -0,0 +1,62 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), token: c.token };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}${endpoint}`);
+    url.searchParams.set("authtoken", conn.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(`Rundeck error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function rundeck(rl) {
+    rl.setName("rundeck");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Rundeck server URL (e.g. https://rundeck.example.com)", env: "RUNDECK_URL" },
+        token: { type: "string", required: true, description: "Rundeck API token", env: "RUNDECK_TOKEN" },
+    });
+    rl.registerAction("job.execute", {
+        description: "Execute a Rundeck job",
+        inputSchema: {
+            jobId: { type: "string", required: true },
+            arguments: { type: "object", required: false, description: "Array of {name, value} argument pairs" },
+            filter: { type: "string", required: false, description: "Node filter string" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const conn = getConn(ctx);
+            let argString = "";
+            if (p.arguments) {
+                for (const arg of p.arguments) {
+                    argString += `-${arg.name} ${arg.value} `;
+                }
+            }
+            const qs = {};
+            if (p.filter)
+                qs.filter = p.filter;
+            return apiRequest(conn, "POST", `/api/14/job/${p.jobId}/run`, { argString: argString.trim() }, qs);
+        },
+    });
+    rl.registerAction("job.getMetadata", {
+        description: "Get metadata for a Rundeck job",
+        inputSchema: { jobId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { jobId } = input;
+            return apiRequest(getConn(ctx), "GET", `/api/18/job/${jobId}/info`);
+        },
+    });
+}

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

@@ -0,0 +1,94 @@
+const API_VERSION = "v59.0";
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { instanceUrl: c.instanceUrl.replace(/\/$/, ""), accessToken: c.accessToken };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.instanceUrl}/services/data/${API_VERSION}${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}`, "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.status === 204)
+        return { success: true };
+    if (!res.ok)
+        throw new Error(`Salesforce error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+const SOBJECTS = ["Account", "Contact", "Lead", "Opportunity", "Case", "Task", "User"];
+const DEFAULT_FIELDS = {
+    Account: "Id,Name,Type",
+    Contact: "Id,FirstName,LastName,Email",
+    Lead: "Id,Company,FirstName,LastName,Email,Status",
+    Opportunity: "Id,AccountId,Amount,Probability,StageName",
+    Case: "Id,AccountId,ContactId,Priority,Status,Subject",
+    Task: "Id,Subject,Status,Priority",
+    User: "Id,Name,Email",
+};
+function registerSObject(rl, sObject, conn) {
+    const lower = sObject.toLowerCase();
+    rl.registerAction(`${lower}.create`, { description: `Create a ${sObject}`, inputSchema: { data: { type: "object", required: true, description: `${sObject} field values` } },
+        async execute(input, ctx) { return api(conn(ctx), "POST", `/sobjects/${sObject}`, input.data); } });
+    rl.registerAction(`${lower}.get`, { description: `Get a ${sObject} by ID`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(conn(ctx), "GET", `/sobjects/${sObject}/${input.id}`); } });
+    rl.registerAction(`${lower}.update`, { description: `Update a ${sObject}`, inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            await api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.id}`, p.data);
+            return { success: true, id: p.id };
+        } });
+    rl.registerAction(`${lower}.delete`, { description: `Delete a ${sObject}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(conn(ctx), "DELETE", `/sobjects/${sObject}/${input.id}`); return { success: true }; } });
+    rl.registerAction(`${lower}.query`, { description: `Query ${sObject}s with SOQL`, inputSchema: { fields: { type: "string", required: false, description: `Comma-separated (default: ${DEFAULT_FIELDS[sObject] ?? "Id"})` }, where: { type: "string", required: false, description: "SOQL WHERE clause" }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const fields = p.fields || DEFAULT_FIELDS[sObject] || "Id";
+            let q = `SELECT ${fields} FROM ${sObject}`;
+            if (p.where)
+                q += ` WHERE ${p.where}`;
+            if (p.limit)
+                q += ` LIMIT ${p.limit}`;
+            const data = (await api(conn(ctx), "GET", "/query", undefined, { q }));
+            return data.records;
+        } });
+    rl.registerAction(`${lower}.upsert`, { description: `Upsert a ${sObject} by external ID`, inputSchema: { externalIdField: { type: "string", required: true }, externalIdValue: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return api(conn(ctx), "PATCH", `/sobjects/${sObject}/${p.externalIdField}/${p.externalIdValue}`, p.data);
+        } });
+}
+export default function salesforce(rl) {
+    rl.setName("salesforce");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        instanceUrl: { type: "string", required: true, description: "Salesforce instance URL (e.g. https://yourorg.my.salesforce.com)", env: "SALESFORCE_INSTANCE_URL" },
+        accessToken: { type: "string", required: true, description: "Salesforce OAuth2 access token", env: "SALESFORCE_ACCESS_TOKEN" },
+    });
+    for (const sObject of SOBJECTS) {
+        registerSObject(rl, sObject, getConn);
+    }
+    // ── Generic sObject ─────────────────────────────────
+    rl.registerAction("sobject.create", { description: "Create any sObject record", inputSchema: { sObject: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "POST", `/sobjects/${p.sObject}`, p.data); } });
+    rl.registerAction("sobject.get", { description: "Get any sObject record", inputSchema: { sObject: { type: "string", required: true }, id: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "GET", `/sobjects/${p.sObject}/${p.id}`); } });
+    rl.registerAction("sobject.update", { description: "Update any sObject record", inputSchema: { sObject: { type: "string", required: true }, id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; await api(getConn(ctx), "PATCH", `/sobjects/${p.sObject}/${p.id}`, p.data); return { success: true }; } });
+    rl.registerAction("sobject.delete", { description: "Delete any sObject record", inputSchema: { sObject: { type: "string", required: true }, id: { type: "string", required: true } },
+        async execute(input, ctx) { const p = input; await api(getConn(ctx), "DELETE", `/sobjects/${p.sObject}/${p.id}`); return { success: true }; } });
+    // ── SOQL Query ──────────────────────────────────────
+    rl.registerAction("soql.query", { description: "Execute a raw SOQL query", inputSchema: { query: { type: "string", required: true, description: "Full SOQL query" } },
+        async execute(input, ctx) {
+            const data = (await api(getConn(ctx), "GET", "/query", undefined, { q: input.query }));
+            return data.records;
+        } });
+    // ── Describe ────────────────────────────────────────
+    rl.registerAction("sobject.describe", { description: "Describe an sObject's metadata/fields", inputSchema: { sObject: { type: "string", required: true } },
+        async execute(input, ctx) { return api(getConn(ctx), "GET", `/sobjects/${input.sObject}/describe`); } });
+}

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

@@ -0,0 +1,83 @@
+const BASE = "https://apis.salesmate.io";
+function getConn(ctx) {
+    return { sessionToken: ctx.connection.config.sessionToken, linkname: ctx.connection.config.linkname };
+}
+async function api(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: { sessionToken: conn.sessionToken, "x-linkname": conn.linkname, "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(`Salesmate error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function registerCrud(rl, resource, plural, conn, createSchema) {
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: createSchema,
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "POST", `/v1/${plural}`, input));
+            return data.Data;
+        } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource} by ID`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "GET", `/v1/${plural}/${input.id}`));
+            return data.Data;
+        } });
+    rl.registerAction(`${resource}.list`, { description: `Search/list ${plural}`, inputSchema: { limit: { type: "number", required: false }, fields: { type: "object", required: false, description: "Array of field names to return" }, query: { type: "object", required: false, description: "Search query object" } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = { fields: p.fields ?? ["name", "id"], query: p.query ?? {} };
+            const qs = {};
+            if (p.limit)
+                qs.rows = p.limit;
+            const data = (await api(conn(ctx), "POST", `/v2/${plural}/search`, body, qs));
+            return data.Data.data;
+        } });
+    rl.registerAction(`${resource}.update`, { description: `Update a ${resource}`, inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(conn(ctx), "PUT", `/v1/${plural}/${p.id}`, p.data));
+            return data.Data;
+        } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(conn(ctx), "DELETE", `/v1/${plural}/${input.id}`); } });
+}
+export default function salesmate(rl) {
+    rl.setName("salesmate");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        sessionToken: { type: "string", required: true, description: "Salesmate session token", env: "SALESMATE_SESSION_TOKEN" },
+        linkname: { type: "string", required: true, description: "Salesmate workspace linkname (subdomain)", env: "SALESMATE_LINKNAME" },
+    });
+    registerCrud(rl, "company", "companies", getConn, {
+        name: { type: "string", required: true },
+        owner: { type: "number", required: true },
+        website: { type: "string", required: false },
+        phone: { type: "string", required: false },
+        description: { type: "string", required: false },
+    });
+    registerCrud(rl, "activity", "activities", getConn, {
+        title: { type: "string", required: true },
+        owner: { type: "number", required: true },
+        type: { type: "string", required: true, description: "e.g. call, email, task" },
+        description: { type: "string", required: false },
+        dueDate: { type: "string", required: false },
+    });
+    registerCrud(rl, "deal", "deals", getConn, {
+        title: { type: "string", required: true },
+        owner: { type: "number", required: true },
+        primaryContact: { type: "number", required: true },
+        pipeline: { type: "string", required: true },
+        status: { type: "string", required: true },
+        stage: { type: "string", required: true },
+        currency: { type: "string", required: true },
+        dealValue: { type: "number", required: false },
+        description: { type: "string", required: false },
+    });
+}