runline 0.1.0

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

@@ -0,0 +1,273 @@
+async function apiRequest(host, apiKey, apiUsername, method, endpoint, body, qs) {
+    const url = new URL(`${host}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "Api-Key": apiKey,
+            "Api-Username": apiUsername,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Discourse API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    return {
+        host: cfg.host.replace(/\/$/, ""),
+        apiKey: cfg.apiKey,
+        apiUsername: cfg.apiUsername ?? "system",
+    };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { host, apiKey, apiUsername } = getConn(ctx);
+    return apiRequest(host, apiKey, apiUsername, method, endpoint, body, qs);
+}
+export default function discourse(rl) {
+    rl.setName("discourse");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "Discourse instance URL (e.g. https://forum.example.com)", env: "DISCOURSE_HOST" },
+        apiKey: { type: "string", required: true, description: "Discourse API key", env: "DISCOURSE_API_KEY" },
+        apiUsername: { type: "string", required: false, description: "API username (default: system)", env: "DISCOURSE_API_USERNAME", default: "system" },
+    });
+    // ── Category ────────────────────────────────────────
+    rl.registerAction("category.create", {
+        description: "Create a category",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Category name" },
+            color: { type: "string", required: true, description: "Hex color (e.g. 0088CC)" },
+            textColor: { type: "string", required: true, description: "Text hex color (e.g. FFFFFF)" },
+        },
+        async execute(input, ctx) {
+            const { name, color, textColor } = input;
+            const data = (await req(ctx, "POST", "/categories.json", { name, color, text_color: textColor }));
+            return data.category;
+        },
+    });
+    rl.registerAction("category.list", {
+        description: "List all categories",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await req(ctx, "GET", "/categories.json"));
+            const list = data.category_list.categories;
+            if (limit)
+                return list.slice(0, limit);
+            return list;
+        },
+    });
+    rl.registerAction("category.update", {
+        description: "Update a category",
+        inputSchema: {
+            categoryId: { type: "string", required: true, description: "Category ID" },
+            name: { type: "string", required: true, description: "New name" },
+            color: { type: "string", required: false, description: "New hex color" },
+            textColor: { type: "string", required: false, description: "New text color" },
+        },
+        async execute(input, ctx) {
+            const { categoryId, name, color, textColor } = input;
+            const body = { name };
+            if (color)
+                body.color = color;
+            if (textColor)
+                body.text_color = textColor;
+            const data = (await req(ctx, "PUT", `/categories/${categoryId}.json`, body));
+            return data.category;
+        },
+    });
+    // ── Group ───────────────────────────────────────────
+    rl.registerAction("group.create", {
+        description: "Create a group",
+        inputSchema: { name: { type: "string", required: true, description: "Group name" } },
+        async execute(input, ctx) {
+            const { name } = input;
+            const data = (await req(ctx, "POST", "/admin/groups.json", { group: { name } }));
+            return data.basic_group;
+        },
+    });
+    rl.registerAction("group.get", {
+        description: "Get a group by name",
+        inputSchema: { name: { type: "string", required: true, description: "Group name" } },
+        async execute(input, ctx) {
+            const { name } = input;
+            const data = (await req(ctx, "GET", `/groups/${name}`));
+            return data.group;
+        },
+    });
+    rl.registerAction("group.list", {
+        description: "List all groups",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await req(ctx, "GET", "/groups.json"));
+            const groups = data.groups;
+            if (limit)
+                return groups.slice(0, limit);
+            return groups;
+        },
+    });
+    rl.registerAction("group.update", {
+        description: "Update a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+            name: { type: "string", required: true, description: "New group name" },
+        },
+        async execute(input, ctx) {
+            const { groupId, name } = input;
+            return req(ctx, "PUT", `/groups/${groupId}.json`, { group: { name } });
+        },
+    });
+    // ── Post ────────────────────────────────────────────
+    rl.registerAction("post.create", {
+        description: "Create a post (new topic or reply)",
+        inputSchema: {
+            title: { type: "string", required: false, description: "Topic title (required for new topics)" },
+            content: { type: "string", required: true, description: "Post content (raw markdown)" },
+            categoryId: { type: "number", required: false, description: "Category ID (for new topics)" },
+            topicId: { type: "number", required: false, description: "Topic ID (for replies)" },
+            replyToPostNumber: { type: "number", required: false, description: "Post number to reply to" },
+        },
+        async execute(input, ctx) {
+            const { title, content, categoryId, topicId, replyToPostNumber } = input;
+            const body = { raw: content };
+            if (title)
+                body.title = title;
+            if (categoryId)
+                body.category = categoryId;
+            if (topicId)
+                body.topic_id = topicId;
+            if (replyToPostNumber)
+                body.reply_to_post_number = replyToPostNumber;
+            return req(ctx, "POST", "/posts.json", body);
+        },
+    });
+    rl.registerAction("post.get", {
+        description: "Get a post by ID",
+        inputSchema: { postId: { type: "string", required: true, description: "Post ID" } },
+        async execute(input, ctx) {
+            return req(ctx, "GET", `/posts/${input.postId}`);
+        },
+    });
+    rl.registerAction("post.list", {
+        description: "List latest posts",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await req(ctx, "GET", "/posts.json"));
+            const posts = data.latest_posts;
+            if (limit)
+                return posts.slice(0, limit);
+            return posts;
+        },
+    });
+    rl.registerAction("post.update", {
+        description: "Update a post",
+        inputSchema: {
+            postId: { type: "string", required: true, description: "Post ID" },
+            content: { type: "string", required: true, description: "New content (raw markdown)" },
+            editReason: { type: "string", required: false, description: "Reason for edit" },
+        },
+        async execute(input, ctx) {
+            const { postId, content, editReason } = input;
+            const body = { raw: content };
+            if (editReason)
+                body.edit_reason = editReason;
+            const data = (await req(ctx, "PUT", `/posts/${postId}.json`, body));
+            return data.post;
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.create", {
+        description: "Create a user",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Full name" },
+            email: { type: "string", required: true, description: "Email address" },
+            username: { type: "string", required: true, description: "Username" },
+            password: { type: "string", required: true, description: "Password" },
+            active: { type: "boolean", required: false, description: "Create as active (default: false)" },
+        },
+        async execute(input, ctx) {
+            const { name, email, username, password, active } = input;
+            const body = { name, email, username, password };
+            if (active !== undefined)
+                body.active = active;
+            return req(ctx, "POST", "/users.json", body);
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user by username or external ID",
+        inputSchema: {
+            username: { type: "string", required: false, description: "Username" },
+            externalId: { type: "string", required: false, description: "External (SSO) ID" },
+        },
+        async execute(input, ctx) {
+            const { username, externalId } = (input ?? {});
+            if (externalId)
+                return req(ctx, "GET", `/u/by-external/${externalId}.json`);
+            if (username)
+                return req(ctx, "GET", `/users/${username}`);
+            throw new Error("Provide either username or externalId");
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users (admin)",
+        inputSchema: {
+            flag: { type: "string", required: false, description: "Filter: active (default), new, staff, suspended, blocked" },
+            limit: { type: "number", required: false, description: "Max results" },
+            order: { type: "string", required: false, description: "Order by field" },
+            asc: { type: "boolean", required: false, description: "Ascending order" },
+            showEmails: { type: "boolean", required: false, description: "Include email addresses" },
+        },
+        async execute(input, ctx) {
+            const { flag = "active", limit, order, asc, showEmails } = (input ?? {});
+            const qs = {};
+            if (order)
+                qs.order = order;
+            if (asc !== undefined)
+                qs.asc = asc;
+            if (showEmails)
+                qs.show_emails = true;
+            let data = (await req(ctx, "GET", `/admin/users/list/${flag}.json`, undefined, qs));
+            if (limit)
+                data = data.slice(0, limit);
+            return data;
+        },
+    });
+    // ── User Group ──────────────────────────────────────
+    rl.registerAction("userGroup.add", {
+        description: "Add users to a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+            usernames: { type: "string", required: true, description: "Comma-separated usernames" },
+        },
+        async execute(input, ctx) {
+            const { groupId, usernames } = input;
+            return req(ctx, "PUT", `/groups/${groupId}/members.json`, { usernames });
+        },
+    });
+    rl.registerAction("userGroup.remove", {
+        description: "Remove users from a group",
+        inputSchema: {
+            groupId: { type: "string", required: true, description: "Group ID" },
+            usernames: { type: "string", required: true, description: "Comma-separated usernames" },
+        },
+        async execute(input, ctx) {
+            const { groupId, usernames } = input;
+            return req(ctx, "DELETE", `/groups/${groupId}/members.json`, { usernames });
+        },
+    });
+}

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

@@ -0,0 +1,145 @@
+const BASE_URL = "https://disqus.com/api/3.0";
+async function apiRequest(apiKey, endpoint, qs) {
+    const url = new URL(`${BASE_URL}/${endpoint}`);
+    url.searchParams.set("api_key", apiKey);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v === undefined || v === null)
+                continue;
+            if (Array.isArray(v)) {
+                for (const item of v)
+                    url.searchParams.append(k, String(item));
+            }
+            else {
+                url.searchParams.set(k, String(v));
+            }
+        }
+    }
+    const res = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!res.ok)
+        throw new Error(`Disqus API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginate(apiKey, endpoint, qs, limit) {
+    const results = [];
+    let cursor;
+    do {
+        const q = { ...qs, limit: 100 };
+        if (cursor)
+            q.cursor = cursor;
+        const data = (await apiRequest(apiKey, endpoint, q));
+        const items = data.response;
+        results.push(...items);
+        const c = data.cursor;
+        if (c?.more && c?.hasNext) {
+            cursor = c.id;
+        }
+        else {
+            break;
+        }
+        if (limit && results.length >= limit)
+            break;
+    } while (true);
+    return limit ? results.slice(0, limit) : results;
+}
+export default function disqus(rl) {
+    rl.setName("disqus");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Disqus API key (access token)", env: "DISQUS_API_KEY" },
+    });
+    rl.registerAction("forum.get", {
+        description: "Get forum details",
+        inputSchema: {
+            forum: { type: "string", required: true, description: "Forum short name (ID)" },
+            related: { type: "array", required: false, description: "Relations to include (e.g. ['author'])" },
+            attach: { type: "array", required: false, description: "Attach fields (e.g. ['counters'])" },
+        },
+        async execute(input, ctx) {
+            const { forum, related, attach } = input;
+            const apiKey = ctx.connection.config.apiKey;
+            const qs = { forum };
+            if (related)
+                qs.related = related;
+            if (attach)
+                qs.attach = attach;
+            const data = (await apiRequest(apiKey, "forums/details.json", qs));
+            return data.response;
+        },
+    });
+    rl.registerAction("forum.listPosts", {
+        description: "List posts in a forum",
+        inputSchema: {
+            forum: { type: "string", required: true, description: "Forum short name" },
+            limit: { type: "number", required: false, description: "Max results" },
+            order: { type: "string", required: false, description: "Sort order: asc or desc" },
+            query: { type: "string", required: false, description: "Search query" },
+            since: { type: "string", required: false, description: "Filter posts since (ISO datetime or unix timestamp)" },
+            related: { type: "array", required: false, description: "Relations (e.g. ['thread'])" },
+            include: { type: "array", required: false, description: "Include filters (e.g. ['approved'])" },
+            filters: { type: "array", required: false, description: "Post filters (e.g. ['Is_Flagged'])" },
+        },
+        async execute(input, ctx) {
+            const { forum, limit, order, query, since, related, include, filters } = (input ?? {});
+            const apiKey = ctx.connection.config.apiKey;
+            const qs = { forum };
+            if (order)
+                qs.order = order;
+            if (query)
+                qs.query = query;
+            if (since)
+                qs.since = since;
+            if (related)
+                qs.related = related;
+            if (include)
+                qs.include = include;
+            if (filters)
+                qs.filters = filters;
+            return paginate(apiKey, "forums/listPosts.json", qs, limit);
+        },
+    });
+    rl.registerAction("forum.listCategories", {
+        description: "List categories in a forum",
+        inputSchema: {
+            forum: { type: "string", required: true, description: "Forum short name" },
+            limit: { type: "number", required: false, description: "Max results" },
+            order: { type: "string", required: false, description: "Sort order: asc or desc" },
+        },
+        async execute(input, ctx) {
+            const { forum, limit, order } = (input ?? {});
+            const apiKey = ctx.connection.config.apiKey;
+            const qs = { forum };
+            if (order)
+                qs.order = order;
+            return paginate(apiKey, "forums/listCategories.json", qs, limit);
+        },
+    });
+    rl.registerAction("forum.listThreads", {
+        description: "List threads in a forum",
+        inputSchema: {
+            forum: { type: "string", required: true, description: "Forum short name" },
+            limit: { type: "number", required: false, description: "Max results" },
+            order: { type: "string", required: false, description: "Sort order: asc or desc" },
+            since: { type: "string", required: false, description: "Filter since (ISO datetime or unix timestamp)" },
+            related: { type: "array", required: false, description: "Relations (e.g. ['author', 'forum'])" },
+            include: { type: "array", required: false, description: "Thread states (e.g. ['open', 'closed', 'killed'])" },
+            thread: { type: "string", required: false, description: "Look up specific thread by ID or ident" },
+        },
+        async execute(input, ctx) {
+            const { forum, limit, order, since, related, include, thread } = (input ?? {});
+            const apiKey = ctx.connection.config.apiKey;
+            const qs = { forum };
+            if (order)
+                qs.order = order;
+            if (since)
+                qs.since = since;
+            if (related)
+                qs.related = related;
+            if (include)
+                qs.include = include;
+            if (thread)
+                qs.thread = thread;
+            return paginate(apiKey, "forums/listThreads.json", qs, limit);
+        },
+    });
+}

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

@@ -0,0 +1,76 @@
+import { commandExists, syncExec } from "runline";
+export default function docker(rl) {
+    rl.setName("docker");
+    rl.setVersion("0.1.0");
+    rl.onInit(() => {
+        if (!commandExists("docker")) {
+            rl.log.warn("docker not found on PATH — docker actions will be unavailable");
+        }
+    });
+    rl.registerAction("containers.list", {
+        description: "List Docker containers",
+        inputSchema: {
+            all: { type: "boolean", description: "Include stopped containers", required: false },
+        },
+        execute(input) {
+            const opts = input ?? {};
+            const args = ["ps", "--format", "{{json .}}", "--no-trunc"];
+            if (opts.all)
+                args.push("--all");
+            const { rows } = syncExec("docker", args, { parser: "jsonlines" });
+            return rows.map((r) => ({
+                id: r.ID ?? r.id ?? "",
+                name: (r.Names ?? r.names ?? "").replace(/^\//, ""),
+                image: r.Image ?? r.image ?? "",
+                status: r.Status ?? r.status ?? "",
+                state: r.State ?? r.state ?? "",
+                ports: r.Ports ?? r.ports ?? "",
+            }));
+        },
+    });
+    rl.registerAction("containers.start", {
+        description: "Start a Docker container",
+        inputSchema: {
+            id: { type: "string", description: "Container ID or name", required: true },
+        },
+        execute(input) {
+            const { id } = input;
+            syncExec("docker", ["start", id]);
+            return { ok: true, id };
+        },
+    });
+    rl.registerAction("containers.stop", {
+        description: "Stop a Docker container",
+        inputSchema: {
+            id: { type: "string", description: "Container ID or name", required: true },
+        },
+        execute(input) {
+            const { id } = input;
+            syncExec("docker", ["stop", id]);
+            return { ok: true, id };
+        },
+    });
+    rl.registerAction("images.list", {
+        description: "List Docker images",
+        execute() {
+            const { rows } = syncExec("docker", ["images", "--format", "{{json .}}", "--no-trunc"], { parser: "jsonlines" });
+            return rows.map((r) => ({
+                id: r.ID ?? r.id ?? "",
+                repository: r.Repository ?? r.repository ?? "",
+                tag: r.Tag ?? r.tag ?? "",
+                size: r.Size ?? r.size ?? "",
+            }));
+        },
+    });
+    rl.registerAction("images.pull", {
+        description: "Pull a Docker image",
+        inputSchema: {
+            image: { type: "string", description: "Image name (e.g. nginx:latest)", required: true },
+        },
+        execute(input) {
+            const { image } = input;
+            syncExec("docker", ["pull", image]);
+            return { ok: true, image };
+        },
+    });
+}

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

@@ -0,0 +1,89 @@
+const BASE_URL = "https://driftapi.com";
+async function apiRequest(token, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Drift API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function drift(rl) {
+    rl.setName("drift");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Drift API access token", env: "DRIFT_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("contact.create", {
+        description: "Create a contact",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address" },
+            name: { type: "string", required: false, description: "Full name" },
+            phone: { type: "string", required: false, description: "Phone number" },
+        },
+        async execute(input, ctx) {
+            const { email, name, phone } = input;
+            const attrs = { email };
+            if (name)
+                attrs.name = name;
+            if (phone)
+                attrs.phone = phone;
+            const data = (await apiRequest(tok(ctx), "POST", "/contacts", { attributes: attrs }));
+            return data.data;
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(tok(ctx), "GET", `/contacts/${input.contactId}`));
+            return data.data;
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            email: { type: "string", required: false, description: "New email" },
+            name: { type: "string", required: false, description: "New name" },
+            phone: { type: "string", required: false, description: "New phone" },
+        },
+        async execute(input, ctx) {
+            const { contactId, email, name, phone } = input;
+            const attrs = {};
+            if (email)
+                attrs.email = email;
+            if (name)
+                attrs.name = name;
+            if (phone)
+                attrs.phone = phone;
+            const data = (await apiRequest(tok(ctx), "PATCH", `/contacts/${contactId}`, { attributes: attrs }));
+            return data.data;
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: { contactId: { type: "string", required: true, description: "Contact ID" } },
+        async execute(input, ctx) {
+            await apiRequest(tok(ctx), "DELETE", `/contacts/${input.contactId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("contact.getCustomAttributes", {
+        description: "List all custom contact attributes",
+        async execute(_input, ctx) {
+            const data = (await apiRequest(tok(ctx), "GET", "/contacts/attributes"));
+            return data.data.properties;
+        },
+    });
+}