runline 0.1.0

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

@@ -0,0 +1,358 @@
+async function apiRequest(server, token, method, endpoint, body, qs) {
+    const url = new URL(`${server}/api/v4${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: { "PRIVATE-TOKEN": 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(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`GitLab API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return {
+        server: (ctx.connection.config.server ?? "https://gitlab.com").replace(/\/$/, ""),
+        token: ctx.connection.config.token,
+    };
+}
+function gl(ctx, method, endpoint, body, qs) {
+    const { server, token } = getConn(ctx);
+    return apiRequest(server, token, method, endpoint, body, qs);
+}
+function projectPath(owner, repo) {
+    return `/projects/${encodeURIComponent(`${owner}/${repo}`)}`;
+}
+export default function gitlab(rl) {
+    rl.setName("gitlab");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        server: { type: "string", required: false, description: "GitLab server URL (default: https://gitlab.com)", env: "GITLAB_SERVER", default: "https://gitlab.com" },
+        token: { type: "string", required: true, description: "GitLab personal access token", env: "GITLAB_TOKEN" },
+    });
+    // ── Issue ───────────────────────────────────────────
+    rl.registerAction("issue.create", {
+        description: "Create an issue",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Group/user namespace" },
+            repo: { type: "string", required: true, description: "Project name" },
+            title: { type: "string", required: true, description: "Issue title" },
+            description: { type: "string", required: false, description: "Issue description (markdown)" },
+            labels: { type: "string", required: false, description: "Comma-separated labels" },
+            assigneeIds: { type: "array", required: false, description: "Array of assignee user IDs" },
+            dueDate: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, title, description: desc, labels, assigneeIds, dueDate } = input;
+            const body = { title };
+            if (desc)
+                body.description = desc;
+            if (labels)
+                body.labels = labels;
+            if (assigneeIds)
+                body.assignee_ids = assigneeIds;
+            if (dueDate)
+                body.due_date = dueDate;
+            return gl(ctx, "POST", `${projectPath(owner, repo)}/issues`, body);
+        },
+    });
+    rl.registerAction("issue.get", {
+        description: "Get an issue",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            issueIid: { type: "number", required: true, description: "Issue IID" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, issueIid } = input;
+            return gl(ctx, "GET", `${projectPath(owner, repo)}/issues/${issueIid}`);
+        },
+    });
+    rl.registerAction("issue.update", {
+        description: "Update an issue",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            issueIid: { type: "number", required: true, description: "Issue IID" },
+            title: { type: "string", required: false, description: "New title" },
+            description: { type: "string", required: false, description: "New description" },
+            labels: { type: "string", required: false, description: "Comma-separated labels" },
+            assigneeIds: { type: "array", required: false, description: "Assignee IDs" },
+            stateEvent: { type: "string", required: false, description: "close or reopen" },
+            dueDate: { type: "string", required: false, description: "Due date" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, issueIid, title, description: desc, labels, assigneeIds, stateEvent, dueDate } = input;
+            const body = {};
+            if (title)
+                body.title = title;
+            if (desc !== undefined)
+                body.description = desc;
+            if (labels !== undefined)
+                body.labels = labels;
+            if (assigneeIds)
+                body.assignee_ids = assigneeIds;
+            if (stateEvent)
+                body.state_event = stateEvent;
+            if (dueDate)
+                body.due_date = dueDate;
+            return gl(ctx, "PUT", `${projectPath(owner, repo)}/issues/${issueIid}`, body);
+        },
+    });
+    rl.registerAction("issue.createNote", {
+        description: "Create a comment (note) on an issue",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            issueIid: { type: "number", required: true, description: "Issue IID" },
+            body: { type: "string", required: true, description: "Comment body (markdown)" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, issueIid, body: noteBody } = input;
+            return gl(ctx, "POST", `${projectPath(owner, repo)}/issues/${issueIid}/notes`, { body: noteBody });
+        },
+    });
+    rl.registerAction("issue.lock", {
+        description: "Lock an issue's discussion",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            issueIid: { type: "number", required: true, description: "Issue IID" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, issueIid } = input;
+            return gl(ctx, "PUT", `${projectPath(owner, repo)}/issues/${issueIid}`, { discussion_locked: true });
+        },
+    });
+    // ── Release ─────────────────────────────────────────
+    rl.registerAction("release.create", {
+        description: "Create a release",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID or path" },
+            tagName: { type: "string", required: true, description: "Tag name" },
+            name: { type: "string", required: false, description: "Release name" },
+            description: { type: "string", required: false, description: "Release notes (markdown)" },
+            ref: { type: "string", required: false, description: "Commit SHA or branch for new tag" },
+            milestones: { type: "array", required: false, description: "Milestone titles" },
+        },
+        async execute(input, ctx) {
+            const { projectId, tagName, name, description: desc, ref, milestones } = input;
+            const body = { tag_name: tagName };
+            if (name)
+                body.name = name;
+            if (desc)
+                body.description = desc;
+            if (ref)
+                body.ref = ref;
+            if (milestones)
+                body.milestones = milestones;
+            return gl(ctx, "POST", `/projects/${encodeURIComponent(projectId)}/releases`, body);
+        },
+    });
+    rl.registerAction("release.get", {
+        description: "Get a release by tag",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID or path" },
+            tagName: { type: "string", required: true, description: "Tag name" },
+        },
+        async execute(input, ctx) {
+            const { projectId, tagName } = input;
+            return gl(ctx, "GET", `/projects/${encodeURIComponent(projectId)}/releases/${encodeURIComponent(tagName)}`);
+        },
+    });
+    rl.registerAction("release.list", {
+        description: "List releases",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID or path" },
+            limit: { type: "number", required: false, description: "Max results" },
+            orderBy: { type: "string", required: false, description: "released_at or created_at" },
+            sort: { type: "string", required: false, description: "asc or desc" },
+        },
+        async execute(input, ctx) {
+            const { projectId, limit, orderBy, sort } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (orderBy)
+                qs.order_by = orderBy;
+            if (sort)
+                qs.sort = sort;
+            return gl(ctx, "GET", `/projects/${encodeURIComponent(projectId)}/releases`, undefined, qs);
+        },
+    });
+    rl.registerAction("release.update", {
+        description: "Update a release",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID or path" },
+            tagName: { type: "string", required: true, description: "Tag name" },
+            name: { type: "string", required: false, description: "New name" },
+            description: { type: "string", required: false, description: "New description" },
+            milestones: { type: "array", required: false, description: "Milestone titles" },
+        },
+        async execute(input, ctx) {
+            const { projectId, tagName, name, description: desc, milestones } = input;
+            const body = {};
+            if (name)
+                body.name = name;
+            if (desc !== undefined)
+                body.description = desc;
+            if (milestones)
+                body.milestones = milestones;
+            return gl(ctx, "PUT", `/projects/${encodeURIComponent(projectId)}/releases/${encodeURIComponent(tagName)}`, body);
+        },
+    });
+    rl.registerAction("release.delete", {
+        description: "Delete a release",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project ID or path" },
+            tagName: { type: "string", required: true, description: "Tag name" },
+        },
+        async execute(input, ctx) {
+            const { projectId, tagName } = input;
+            await gl(ctx, "DELETE", `/projects/${encodeURIComponent(projectId)}/releases/${encodeURIComponent(tagName)}`);
+            return { success: true };
+        },
+    });
+    // ── Repository ──────────────────────────────────────
+    rl.registerAction("repository.get", {
+        description: "Get project details",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo } = input;
+            return gl(ctx, "GET", projectPath(owner, repo));
+        },
+    });
+    rl.registerAction("repository.listIssues", {
+        description: "List issues for a project",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            state: { type: "string", required: false, description: "opened, closed, all" },
+            labels: { type: "string", required: false, description: "Comma-separated labels" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, state, labels, limit } = (input ?? {});
+            const qs = {};
+            if (state)
+                qs.state = state;
+            if (labels)
+                qs.labels = labels;
+            if (limit)
+                qs.per_page = limit;
+            return gl(ctx, "GET", `${projectPath(owner, repo)}/issues`, undefined, qs);
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.listProjects", {
+        description: "List projects for a user",
+        inputSchema: {
+            username: { type: "string", required: true, description: "Username" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { username, limit } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            return gl(ctx, "GET", `/users/${username}/projects`, undefined, qs);
+        },
+    });
+    // ── File ────────────────────────────────────────────
+    rl.registerAction("file.get", {
+        description: "Get a file from repository",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            filePath: { type: "string", required: true, description: "File path" },
+            ref: { type: "string", required: false, description: "Branch/tag/SHA (default: default branch)" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, filePath, ref = "main" } = input;
+            return gl(ctx, "GET", `${projectPath(owner, repo)}/repository/files/${encodeURIComponent(filePath)}`, undefined, { ref });
+        },
+    });
+    rl.registerAction("file.createOrUpdate", {
+        description: "Create or update a file in repository",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            filePath: { type: "string", required: true, description: "File path" },
+            content: { type: "string", required: true, description: "File content" },
+            branch: { type: "string", required: true, description: "Target branch" },
+            commitMessage: { type: "string", required: true, description: "Commit message" },
+            startBranch: { type: "string", required: false, description: "Base branch for new branch" },
+            encoding: { type: "string", required: false, description: "text (default) or base64" },
+            authorName: { type: "string", required: false, description: "Commit author name" },
+            authorEmail: { type: "string", required: false, description: "Commit author email" },
+            isUpdate: { type: "boolean", required: false, description: "true=PUT (update), false=POST (create, default)" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, filePath, content, branch, commitMessage, startBranch, encoding, authorName, authorEmail, isUpdate } = input;
+            const body = { branch, commit_message: commitMessage, content };
+            if (startBranch)
+                body.start_branch = startBranch;
+            if (encoding)
+                body.encoding = encoding;
+            if (authorName)
+                body.author_name = authorName;
+            if (authorEmail)
+                body.author_email = authorEmail;
+            const method = isUpdate ? "PUT" : "POST";
+            return gl(ctx, method, `${projectPath(owner, repo)}/repository/files/${encodeURIComponent(filePath)}`, body);
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file from repository",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            filePath: { type: "string", required: true, description: "File path" },
+            branch: { type: "string", required: true, description: "Branch" },
+            commitMessage: { type: "string", required: true, description: "Commit message" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, filePath, branch, commitMessage } = input;
+            return gl(ctx, "DELETE", `${projectPath(owner, repo)}/repository/files/${encodeURIComponent(filePath)}`, {
+                branch, commit_message: commitMessage,
+            });
+        },
+    });
+    rl.registerAction("file.list", {
+        description: "List repository tree (directory contents)",
+        inputSchema: {
+            owner: { type: "string", required: true, description: "Namespace" },
+            repo: { type: "string", required: true, description: "Project" },
+            path: { type: "string", required: false, description: "Directory path" },
+            ref: { type: "string", required: false, description: "Branch/tag/SHA" },
+            recursive: { type: "boolean", required: false, description: "List recursively" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { owner, repo, path, ref, recursive, limit } = (input ?? {});
+            const qs = {};
+            if (path)
+                qs.path = path;
+            if (ref)
+                qs.ref = ref;
+            if (recursive)
+                qs.recursive = true;
+            if (limit)
+                qs.per_page = limit;
+            return gl(ctx, "GET", `${projectPath(owner, repo)}/repository/tree`, undefined, qs);
+        },
+    });
+}

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

@@ -0,0 +1,126 @@
+async function apiRequest(baseUrl, accessKey, accessKeySecret, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            Authorization: `Basic ${btoa(`${accessKey}:${accessKeySecret}`)}`,
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0) {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${baseUrl}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Gong API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginate(baseUrl, accessKey, accessKeySecret, endpoint, body, resultKey, limit) {
+    const results = [];
+    let cursor;
+    do {
+        const reqBody = { ...body };
+        if (cursor)
+            reqBody.cursor = cursor;
+        const data = (await apiRequest(baseUrl, accessKey, accessKeySecret, "POST", endpoint, reqBody));
+        const items = data[resultKey] ?? [];
+        results.push(...items);
+        cursor = data.records?.cursor;
+        if (limit && results.length >= limit)
+            break;
+    } while (cursor);
+    return limit ? results.slice(0, limit) : results;
+}
+function getConn(ctx) {
+    return {
+        baseUrl: (ctx.connection.config.baseUrl ?? "https://api.gong.io").replace(/\/$/, ""),
+        accessKey: ctx.connection.config.accessKey,
+        accessKeySecret: ctx.connection.config.accessKeySecret,
+    };
+}
+export default function gong(rl) {
+    rl.setName("gong");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: false, description: "Gong API base URL (default: https://api.gong.io)", env: "GONG_BASE_URL", default: "https://api.gong.io" },
+        accessKey: { type: "string", required: true, description: "Gong API access key", env: "GONG_ACCESS_KEY" },
+        accessKeySecret: { type: "string", required: true, description: "Gong API access key secret", env: "GONG_ACCESS_KEY_SECRET" },
+    });
+    rl.registerAction("call.get", {
+        description: "Get detailed call data",
+        inputSchema: {
+            callId: { type: "string", required: true, description: "Call ID" },
+            contentSelector: { type: "object", required: false, description: "Content selector for what data to include (exposedFields object)" },
+        },
+        async execute(input, ctx) {
+            const { callId, contentSelector } = input;
+            const { baseUrl, accessKey, accessKeySecret } = getConn(ctx);
+            const body = { filter: { callIds: [callId] } };
+            if (contentSelector)
+                body.contentSelector = contentSelector;
+            const data = (await apiRequest(baseUrl, accessKey, accessKeySecret, "POST", "/v2/calls/extensive", body));
+            const calls = data.calls;
+            return calls?.[0];
+        },
+    });
+    rl.registerAction("call.list", {
+        description: "List calls",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            fromDateTime: { type: "string", required: false, description: "Calls started after (ISO 8601)" },
+            toDateTime: { type: "string", required: false, description: "Calls started before (ISO 8601)" },
+            workspaceId: { type: "string", required: false, description: "Filter by workspace" },
+            callIds: { type: "array", required: false, description: "Specific call IDs" },
+            primaryUserIds: { type: "array", required: false, description: "Filter by organizer user IDs" },
+        },
+        async execute(input, ctx) {
+            const { limit, fromDateTime, toDateTime, workspaceId, callIds, primaryUserIds } = (input ?? {});
+            const { baseUrl, accessKey, accessKeySecret } = getConn(ctx);
+            const filter = {};
+            if (fromDateTime)
+                filter.fromDateTime = fromDateTime;
+            if (toDateTime)
+                filter.toDateTime = toDateTime;
+            if (workspaceId)
+                filter.workspaceId = workspaceId;
+            if (callIds)
+                filter.callIds = callIds;
+            if (primaryUserIds)
+                filter.primaryUserIds = primaryUserIds;
+            return paginate(baseUrl, accessKey, accessKeySecret, "/v2/calls/extensive", { filter }, "calls", limit);
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a user",
+        inputSchema: { userId: { type: "string", required: true, description: "User ID" } },
+        async execute(input, ctx) {
+            const { userId } = input;
+            const { baseUrl, accessKey, accessKeySecret } = getConn(ctx);
+            const data = (await apiRequest(baseUrl, accessKey, accessKeySecret, "POST", "/v2/users/extensive", {
+                filter: { userIds: [userId] },
+            }));
+            const users = data.users;
+            return users?.[0];
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            createdFromDateTime: { type: "string", required: false, description: "Users created after (ISO 8601)" },
+            createdToDateTime: { type: "string", required: false, description: "Users created before (ISO 8601)" },
+            userIds: { type: "array", required: false, description: "Specific user IDs" },
+        },
+        async execute(input, ctx) {
+            const { limit, createdFromDateTime, createdToDateTime, userIds } = (input ?? {});
+            const { baseUrl, accessKey, accessKeySecret } = getConn(ctx);
+            const filter = {};
+            if (createdFromDateTime)
+                filter.createdFromDateTime = createdFromDateTime;
+            if (createdToDateTime)
+                filter.createdToDateTime = createdToDateTime;
+            if (userIds)
+                filter.userIds = userIds;
+            return paginate(baseUrl, accessKey, accessKeySecret, "/v2/users/extensive", { filter }, "users", limit);
+        },
+    });
+}

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

@@ -0,0 +1,77 @@
+async function apiRequest(url, token, method, endpoint, body, qs) {
+    const fullUrl = new URL(`${url}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                fullUrl.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { "X-Gotify-Key": token, Accept: "application/json", "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(fullUrl.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Gotify API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function gotify(rl) {
+    rl.setName("gotify");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Gotify server URL (e.g. https://gotify.example.com)", env: "GOTIFY_URL" },
+        appApiToken: { type: "string", required: true, description: "Application token (for sending messages)", env: "GOTIFY_APP_TOKEN" },
+        clientApiToken: { type: "string", required: true, description: "Client token (for reading/deleting)", env: "GOTIFY_CLIENT_TOKEN" },
+    });
+    rl.registerAction("message.create", {
+        description: "Send a push message",
+        inputSchema: {
+            message: { type: "string", required: true, description: "Message text" },
+            title: { type: "string", required: false, description: "Message title" },
+            priority: { type: "number", required: false, description: "Priority (default: 1)" },
+            contentType: { type: "string", required: false, description: "text/plain (default) or text/markdown" },
+        },
+        async execute(input, ctx) {
+            const { message, title, priority, contentType } = input;
+            const url = ctx.connection.config.url.replace(/\/$/, "");
+            const token = ctx.connection.config.appApiToken;
+            const body = { message };
+            if (title)
+                body.title = title;
+            if (priority !== undefined)
+                body.priority = priority;
+            if (contentType)
+                body.extras = { "client::display": { contentType } };
+            return apiRequest(url, token, "POST", "/message", body);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: { messageId: { type: "string", required: true, description: "Message ID" } },
+        async execute(input, ctx) {
+            const url = ctx.connection.config.url.replace(/\/$/, "");
+            const token = ctx.connection.config.clientApiToken;
+            await apiRequest(url, token, "DELETE", `/message/${input.messageId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("message.list", {
+        description: "List messages",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" } },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const url = ctx.connection.config.url.replace(/\/$/, "");
+            const token = ctx.connection.config.clientApiToken;
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            const data = (await apiRequest(url, token, "GET", "/message", undefined, qs));
+            return data.messages;
+        },
+    });
+}