github-cicd-mcp 0.0.0-stage → 1.2.0

package/dist/tools/repos.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { getOctokit } from "../lib/github.js";
+import { owner, perPage, repo } from "../lib/fields.js";
+import { errorResult, jsonResult } from "../lib/response.js";
+export function registerRepoTools(server) {
+    server.tool("github_get_authenticated_user", "Get the authenticated GitHub user (validates token and shows login).", {}, async () => {
+        try {
+            const { data } = await getOctokit().rest.users.getAuthenticated();
+            return jsonResult({
+                login: data.login,
+                id: data.id,
+                name: data.name,
+                type: data.type,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_get_rate_limit", "Check REST API rate limit status for the current token.", {}, async () => {
+        try {
+            const { data } = await getOctokit().rest.rateLimit.get();
+            return jsonResult(data);
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_repository", "Create a new repository for the authenticated user or an organization.", {
+        name: z.string().describe("Repository name"),
+        description: z.string().optional().describe("Short description"),
+        private: z.boolean().optional().describe("Private repo (default false)"),
+        org: z.string().optional().describe("Organization login; omit for user account"),
+        auto_init: z.boolean().optional().describe("Initialize with README (default true)"),
+        gitignore_template: z.string().optional().describe("Gitignore template name, e.g. Node"),
+    }, async ({ name, description, private: isPrivate, org, auto_init, gitignore_template }) => {
+        try {
+            const octokit = getOctokit();
+            const body = {
+                name,
+                description: description ?? undefined,
+                private: isPrivate ?? false,
+                auto_init: auto_init ?? true,
+                gitignore_template: gitignore_template ?? undefined,
+            };
+            const { data } = org
+                ? await octokit.rest.repos.createInOrg({ org, ...body })
+                : await octokit.rest.repos.createForAuthenticatedUser(body);
+            return jsonResult({
+                full_name: data.full_name,
+                html_url: data.html_url,
+                clone_url: data.clone_url,
+                default_branch: data.default_branch,
+                private: data.private,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_get_repository", "Get repository metadata.", { owner, repo }, async ({ owner, repo }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.get({ owner, repo });
+            return jsonResult({
+                full_name: data.full_name,
+                description: data.description,
+                default_branch: data.default_branch,
+                html_url: data.html_url,
+                clone_url: data.clone_url,
+                private: data.private,
+                open_issues: data.open_issues_count,
+                pushed_at: data.pushed_at,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_repositories", "List repositories for a user or organization.", {
+        owner,
+        type: z
+            .string()
+            .optional()
+            .describe("For orgs: all | public | private | forks | sources | member"),
+        per_page: perPage,
+    }, async ({ owner, type, per_page }) => {
+        try {
+            const octokit = getOctokit();
+            const { data: user } = await octokit.rest.users.getByUsername({ username: owner });
+            let repos;
+            if (user.type === "Organization") {
+                const res = await octokit.rest.repos.listForOrg({
+                    org: owner,
+                    type: type ?? "all",
+                    per_page: per_page ?? 30,
+                });
+                repos = res.data;
+            }
+            else {
+                const res = await octokit.rest.repos.listForUser({
+                    username: owner,
+                    per_page: per_page ?? 30,
+                });
+                repos = res.data;
+            }
+            return jsonResult(repos.map((r) => ({
+                full_name: r.full_name,
+                private: r.private,
+                default_branch: r.default_branch,
+                html_url: r.html_url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_branch", "Create a branch from an existing ref (e.g. main).", {
+        owner,
+        repo,
+        branch: z.string().describe("New branch name"),
+        from_ref: z
+            .string()
+            .optional()
+            .describe("Source ref (branch or SHA). Default: default branch"),
+    }, async ({ owner, repo, branch, from_ref }) => {
+        try {
+            const octokit = getOctokit();
+            let sha;
+            if (from_ref) {
+                const ref = await octokit.rest.git.getRef({
+                    owner,
+                    repo,
+                    ref: `heads/${from_ref}`,
+                });
+                sha = ref.data.object.sha;
+            }
+            else {
+                const { data: repoData } = await octokit.rest.repos.get({ owner, repo });
+                const ref = await octokit.rest.git.getRef({
+                    owner,
+                    repo,
+                    ref: `heads/${repoData.default_branch}`,
+                });
+                sha = ref.data.object.sha;
+            }
+            const { data } = await octokit.rest.git.createRef({
+                owner,
+                repo,
+                ref: `refs/heads/${branch}`,
+                sha,
+            });
+            return jsonResult({ ref: data.ref, url: data.url });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_fork_repository", "Fork a repository to the authenticated user or an organization.", {
+        owner,
+        repo,
+        organization: z.string().optional().describe("Org to fork into; default: your user"),
+        default_branch_only: z.boolean().optional().describe("Fork only default branch"),
+    }, async ({ owner, repo, organization, default_branch_only }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.createFork({
+                owner,
+                repo,
+                organization: organization ?? undefined,
+                default_branch_only: default_branch_only ?? undefined,
+            });
+            return jsonResult({
+                full_name: data.full_name,
+                html_url: data.html_url,
+                clone_url: data.clone_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/dist/tools/webhooks-collaborators.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerWebhookTools(server: McpServer): void;
+export declare function registerCollaboratorTools(server: McpServer): void;

package/dist/tools/webhooks-collaborators.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+import { owner, perPage, repo } from "../lib/fields.js";
+import { getOctokit } from "../lib/github.js";
+import { errorResult, jsonResult } from "../lib/response.js";
+export function registerWebhookTools(server) {
+    server.tool("github_list_webhooks", "List repository webhooks.", { owner, repo, per_page: perPage }, async ({ owner, repo, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.listWebhooks({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data.map((h) => ({
+                id: h.id,
+                name: h.name,
+                active: h.active,
+                events: h.events,
+                url: h.config.url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_webhook", "Create a repository webhook (e.g. for CI notifications).", {
+        owner,
+        repo,
+        url: z.string().describe("Payload URL"),
+        secret: z.string().optional().describe("Webhook secret"),
+        events: z
+            .string()
+            .optional()
+            .describe('JSON array of events, default ["push","pull_request"]'),
+        active: z.boolean().optional(),
+    }, async ({ owner, repo, url, secret, events, active }) => {
+        try {
+            const eventList = events
+                ? JSON.parse(events)
+                : ["push", "pull_request"];
+            const { data } = await getOctokit().rest.repos.createWebhook({
+                owner,
+                repo,
+                config: {
+                    url,
+                    content_type: "json",
+                    secret: secret ?? undefined,
+                    insecure_ssl: "0",
+                },
+                events: eventList,
+                active: active ?? true,
+            });
+            return jsonResult({ id: data.id, url: data.config.url, events: data.events });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_delete_webhook", "Delete a repository webhook by ID.", {
+        owner,
+        repo,
+        hook_id: z.number(),
+    }, async ({ owner, repo, hook_id }) => {
+        try {
+            await getOctokit().rest.repos.deleteWebhook({ owner, repo, hook_id });
+            return jsonResult({ ok: true, hook_id });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}
+export function registerCollaboratorTools(server) {
+    server.tool("github_list_collaborators", "List collaborators and their permissions.", { owner, repo, per_page: perPage }, async ({ owner, repo, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.listCollaborators({
+                owner,
+                repo,
+                per_page: per_page ?? 100,
+            });
+            return jsonResult(data.map((c) => ({
+                login: c.login,
+                permissions: c.permissions,
+                role_name: c.role_name,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_add_collaborator", "Invite or add a collaborator to a repository.", {
+        owner,
+        repo,
+        username: z.string(),
+        permission: z
+            .string()
+            .optional()
+            .describe("pull | push | admin | maintain | triage (default push)"),
+    }, async ({ owner, repo, username, permission }) => {
+        try {
+            await getOctokit().rest.repos.addCollaborator({
+                owner,
+                repo,
+                username,
+                permission: permission,
+            });
+            return jsonResult({ ok: true, username, permission: permission ?? "push" });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_teams", "List teams in an organization (for CI/CD access planning).", {
+        org: z.string(),
+        per_page: perPage,
+    }, async ({ org, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.teams.list({
+                org,
+                per_page: per_page ?? 100,
+            });
+            return jsonResult(data.map((t) => ({
+                id: t.id,
+                name: t.name,
+                slug: t.slug,
+                privacy: t.privacy,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,61 @@
-{
-  "name": "github-cicd-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "github-cicd-mcp",
+  "version": "1.2.0",
+  "description": "MCP server for GitHub REST & GraphQL — repos, commits, PRs, issues, Actions CI/CD, releases, billing, and local git",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "bin": {
+    "github-cicd-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build",
+    "verify": "npm run build && node scripts/count-tools.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "github",
+    "ci-cd",
+    "devops",
+    "actions",
+    "pull-request"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devstephenke-sys/Github-Free-MCPs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/devstephenke-sys/Github-Free-MCPs/issues"
+  },
+  "homepage": "https://github.com/devstephenke-sys/Github-Free-MCPs#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@octokit/graphql": "^9.0.3",
+    "@octokit/rest": "^22.0.1",
+    "simple-git": "^3.27.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}