@bettercms-ai/mcp 0.52.0 → 0.53.0

package/dist/index.js

@@ -2433,6 +2433,16 @@ function structureResult(d) {
   const message = d?.message;
   return ok(typeof message === "string" ? message : "Updated the Content structure.", d);
 }
+var GIT_TEXT = {
+  list_github_repos: "Every GitHub repository this workspace's connected GitHub App installations can reach, grouped by account. Use it to find the repository to import: each ACCOUNT carries the `installationId` that import_github_repo and fork_github_repo take, and each repository under it carries `owner`, `repo` and `defaultBranch`. An empty `accounts` list means nobody has connected GitHub to this workspace yet \u2014 tell the user to connect it from the dashboard (Project \u2192 Hosting \u2192 Connect GitHub) and call this again.",
+  import_github_repo: "Connect an existing GitHub repository to the connected project \u2014 the agent's equivalent of the dashboard's Import from GitHub, and the thing to do BEFORE writing any code for a user who already has a repo. It provisions the deploy workflow, the project API key and the build variables inside the repository, records the connection, assigns the site handle, imports the repo's bcms-content.json as content models when it has one, and queues the first build. Pass `installationId`, `owner` and `repo` from list_github_repos; `branch` defaults to the repository's own default branch and becomes the branch every deploy builds from. It only works on a repository one of this workspace's installations can already reach \u2014 for anyone else's repository (a public starter, a template, another account's site) use fork_github_repo instead. Read `warning` / `contentWarning` / `actionsWarning` back to the user verbatim when they come back \u2014 they are the cases where the repository connected perfectly and still cannot build, or will leave the Pages tab empty. Re-importing replaces the project's existing connection.",
+  fork_github_repo: "Fork ANY GitHub repository into the user's own account and import it in one step \u2014 how a user starts from a repository that is not theirs (a public starter, a template, another account's site). BetterCMS cannot wire a repository it has no installation on, so the copy has to live on their account first; this makes that copy, keeps the upstream link, and then connects it exactly as import_github_repo does. `installationId` names the DESTINATION account (from list_github_repos); `owner` and `repo` name the SOURCE, anywhere on GitHub. `name` renames the fork; `connect: false` forks without connecting. Forking is asynchronous: a 202 means the fork exists but GitHub is still copying it, and the answer tells you to call import_github_repo with the fork's owner and repo a moment later \u2014 never fork a second time.",
+  list_github_branches: "The connected repository's branches, plus `buildBranch` \u2014 the one the provisioned Action builds from. A commit on any other branch never reaches the live site, so check this before you push.",
+  list_github_commits: "The connected repository's commit history, newest first: sha, message, author, date and url. Defaults to the build branch; pass `branch` for another, `path` to narrow it to one file or directory, and `limit` (1-100, default 20). Read the head sha here before a push you want to be safe, and hand it back as push_to_github's `expectedHeadSha`.",
+  push_to_github: "Commit files to the connected repository \u2014 a real git commit, written server-side with the GitHub App's own credentials, so you need no clone, no remote and no token of your own. Send `files` ([{path, content, encoding}]) and/or `deletePaths`, plus a `message`; both go into ONE commit, so a rename is atomic. It targets the BUILD branch by default, where the push starts the rebuild that goes live \u2014 poll get_deploy_status after it, and read the response's `note`, which says whether this push deploys. Pass `branch` to push somewhere else (a branch that does not exist yet is created from the build branch, or from `baseBranch`) and then open a pull request with create_github_pull_request. Pass `expectedHeadSha` from list_github_commits \u2014 a full sha or a prefix of one \u2014 to be refused with a 409 rather than silently overwrite a branch someone else moved while you worked. Limits, enforced BEFORE anything is written: 200 paths and 10 MB per commit, and `.git`, `.github/workflows`, `.env` and `.npmrc` are never writable \u2014 a refused patch writes nothing at all and names every offending path.",
+  create_github_pull_request: "Open a pull request on the connected repository. `head` is the branch you pushed; `base` defaults to the build branch, so merging it is what ships the change. Use this instead of pushing straight to the build branch whenever a human should review first, or when that branch is protected. Returns the number and the url to hand the user.",
+  list_github_pull_requests: "Pull requests on the connected repository: number, title, state, whether it merged, draft, head, base and url. `state` is 'open' (the default), 'closed' or 'all'. Poll it to find out whether the pull request you opened has landed."
+};
 function ok(summary, data) {
   return {
     content: [
@@ -3559,6 +3569,101 @@ ${res.warnings.join("\n")}` : summary, res.data);
         z.object({ uploadKey: z.string().min(1).describe("the uploadKey from create_deploy_upload, after PUTting the archive to its uploadUrl") }).shape,
         async (c, a) => ok("Deploy queued.", await data(c, "POST", `/management/projects/deploy/from-upload`, { uploadKey: a.uploadKey }))
       ),
+      // ── Git (import a repository, read it, push commits back) ──
+      // Same artifact:write authority as the deploy tools: on the build branch a push IS a
+      // deploy. Every call runs server-side as the GitHub App installation, so the agent
+      // needs no git remote, no clone and no token. @see management/git.ts
+      def(
+        "list_github_repos",
+        "List importable GitHub repositories",
+        GIT_TEXT.list_github_repos,
+        z.object({}).shape,
+        async (c) => ok("GitHub repositories.", await data(c, "GET", `/management/git/repos`))
+      ),
+      def(
+        "import_github_repo",
+        "Import a GitHub repository",
+        GIT_TEXT.import_github_repo,
+        z.object({
+          installationId: z.number().int().positive().describe("from list_github_repos"),
+          owner: z.string().min(1).describe("the repository's account, e.g. 'acme'"),
+          repo: z.string().min(1).describe("the repository name, e.g. 'website'"),
+          branch: z.string().min(1).optional().describe("branch to build from; defaults to the repository's own default branch")
+        }).shape,
+        async (c, a) => ok("Repository imported.", await data(c, "POST", `/management/git/connect`, { installationId: a.installationId, owner: a.owner, repo: a.repo, branch: a.branch }))
+      ),
+      def(
+        "fork_github_repo",
+        "Fork a repository and import it",
+        GIT_TEXT.fork_github_repo,
+        z.object({
+          installationId: z.number().int().positive().describe("the DESTINATION account's installation, from list_github_repos"),
+          owner: z.string().min(1).describe("the SOURCE repository's account, anywhere on GitHub"),
+          repo: z.string().min(1).describe("the SOURCE repository name"),
+          name: z.string().min(1).optional().describe("name for the fork; defaults to the source repository's name"),
+          connect: z.boolean().optional().describe("connect the fork to this project (the default); false forks only")
+        }).shape,
+        async (c, a) => ok("Repository forked.", await data(c, "POST", `/management/git/fork`, { installationId: a.installationId, owner: a.owner, repo: a.repo, name: a.name, connect: a.connect }))
+      ),
+      def(
+        "list_github_branches",
+        "List the repository's branches",
+        GIT_TEXT.list_github_branches,
+        z.object({}).shape,
+        async (c) => ok("Branches.", await data(c, "GET", `/management/git/branches`))
+      ),
+      def(
+        "list_github_commits",
+        "List the repository's commits",
+        GIT_TEXT.list_github_commits,
+        z.object({
+          branch: z.string().min(1).optional().describe("defaults to the build branch"),
+          path: z.string().min(1).optional().describe("only commits touching this file or directory"),
+          limit: z.number().int().min(1).max(100).optional()
+        }).shape,
+        async (c, a) => ok("Commits.", await data(c, "GET", `/management/git/commits${q({ branch: a.branch, path: a.path, limit: a.limit })}`))
+      ),
+      def(
+        "push_to_github",
+        "Push a commit to the repository",
+        GIT_TEXT.push_to_github,
+        z.object({
+          message: z.string().min(1).describe("the commit message"),
+          files: z.array(z.object({
+            path: z.string().min(1).describe("repository-relative path, e.g. 'src/pages/index.astro'"),
+            content: z.string().describe("the file's contents"),
+            encoding: z.enum(["utf8", "base64"]).optional().describe("'base64' for binary files; defaults to utf8")
+          })).optional().describe("files to write or overwrite"),
+          deletePaths: z.array(z.string().min(1)).optional().describe("paths to remove in the same commit"),
+          branch: z.string().min(1).optional().describe("defaults to the build branch; a branch that does not exist is created"),
+          baseBranch: z.string().min(1).optional().describe("what a newly created `branch` starts from; defaults to the build branch"),
+          expectedHeadSha: z.string().min(7).optional().describe("the head you built this change on; the push is refused if the branch moved since")
+        }).shape,
+        async (c, a) => ok("Pushed.", await data(c, "POST", `/management/git/commit`, { message: a.message, files: a.files, deletePaths: a.deletePaths, branch: a.branch, baseBranch: a.baseBranch, expectedHeadSha: a.expectedHeadSha }))
+      ),
+      def(
+        "create_github_pull_request",
+        "Open a pull request",
+        GIT_TEXT.create_github_pull_request,
+        z.object({
+          head: z.string().min(1).describe("the branch you pushed"),
+          base: z.string().min(1).optional().describe("defaults to the build branch"),
+          title: z.string().min(1),
+          body: z.string().optional(),
+          draft: z.boolean().optional()
+        }).shape,
+        async (c, a) => ok("Pull request opened.", await data(c, "POST", `/management/git/pulls`, { head: a.head, base: a.base, title: a.title, body: a.body, draft: a.draft }))
+      ),
+      def(
+        "list_github_pull_requests",
+        "List pull requests",
+        GIT_TEXT.list_github_pull_requests,
+        z.object({
+          state: z.enum(["open", "closed", "all"]).optional(),
+          limit: z.number().int().min(1).max(100).optional()
+        }).shape,
+        async (c, a) => ok("Pull requests.", await data(c, "GET", `/management/git/pulls${q({ state: a.state, limit: a.limit })}`))
+      ),
       // ── Insight: what happened, what's working, what's broken ─────────────────
       def(
         "list_activity",