mcp-fs-shell-windows 0.2.19 → 0.2.29

package/dist/gh/handler.js

@@ -0,0 +1,406 @@
+// gh/handler.ts — gh CLI wrappers for the 8 gh_* tools (MCP filesystem fork).
+//
+// Design: spawn the `gh` binary directly (no new dependency; `git push` for
+// gh_push spawns the git CLI). Every tool operates against the repo at the
+// server process's current working directory (process.cwd()) — the same
+// "current working directory context" the git/shell tools use — and takes NO
+// working-directory parameter (matching the reference Beledarian tools: the
+// reference's gh spawns inherit the plugin process cwd, and gh itself resolves
+// the repo from that cwd's git remote). All argument values (titles, bodies,
+// labels, branch names, issue/PR numbers) are passed as individual argv
+// elements (no shell), so quotes / Unicode / special characters pass through
+// verbatim. Long issue/PR bodies are written to a temp file in the working
+// directory and passed via --body-file (mirroring the reference); the temp
+// file is always removed afterwards.
+//
+// gh binary resolution (port of the reference's checkGhInstalled, with a
+// documented fallback): PATH lookup via `where gh` (win32) / `which gh` first;
+// if gh is not on the server process's PATH, fall back to the known portable
+// install <home>/tools/gh/bin/gh.exe (this machine's layout — gh 2.99.0,
+// authenticated to github.com). If neither is found, the reference's
+// "not installed" error string is returned.
+//
+// gh_auth: runs `gh auth status`; on failure it opens a detached terminal
+// window (cmd /k) for interactive `gh auth login --git-protocol=https` exactly
+// as the reference does — spawned with {detached: true, stdio: "ignore"} so it
+// survives the MCP call returning, using the RESOLVED gh path so the window
+// works even when gh is not on the inherited PATH. The window persists for the
+// user (cmd /k) and can be closed manually.
+//
+// Return shape mirrors the reference implementation: each handler returns a JSON
+// text string carrying the reference's fields ({success, ...} / {error} /
+// {issues} / {pull_requests} / {comments} / {diff} / raw_output) instead of
+// throwing, so a missing gh, a bad remote, or a bad branch yields a clear
+// structured error string rather than a crash or hang.
+import { spawn } from "child_process";
+import fs from "fs";
+import nodeOs from "os";
+import nodePath from "path";
+/** Run `<bin> <args>` with the given cwd. Never rejects; spawn failures resolve with code -1. */
+function runCmd(bin, args, cwd) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(bin, args, { cwd });
+        }
+        catch (e) {
+            resolve({ code: -1, stdout: "", stderr: e instanceof Error ? e.message : String(e) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code, stdout, stderr });
+        };
+        if (child.stdout) {
+            child.stdout.on("data", (d) => {
+                stdout += d.toString("utf8");
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (d) => {
+                stderr += d.toString("utf8");
+            });
+        }
+        child.on("error", (e) => {
+            // e.g. ENOENT when the binary cannot be found
+            stderr += (stderr ? "\n" : "") + (e.message || String(e));
+            finish(-1);
+        });
+        child.on("close", (code) => finish(code === null ? -1 : code));
+    });
+}
+/** Run a shell one-liner (e.g. `where gh`). Never rejects. */
+function runShellLine(cmd) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(cmd, [], { shell: true });
+        }
+        catch (e) {
+            resolve({ code: -1, stdout: "", stderr: e instanceof Error ? e.message : String(e) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code, stdout, stderr });
+        };
+        if (child.stdout) {
+            child.stdout.on("data", (d) => {
+                stdout += d.toString("utf8");
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (d) => {
+                stderr += d.toString("utf8");
+            });
+        }
+        child.on("error", (e) => {
+            stderr += (stderr ? "\n" : "") + (e.message || String(e));
+            finish(-1);
+        });
+        child.on("close", (code) => finish(code === null ? -1 : code));
+    });
+}
+const GH_NOT_INSTALLED = "GitHub CLI ('gh') is not installed. Please ask the user to install it from https://cli.github.com/";
+/** Absolute path of gh on the PATH (first hit of `where gh` / `which gh`), or null. */
+async function findGhOnPath() {
+    const r = await runShellLine(process.platform === "win32" ? "where gh" : "which gh");
+    if (!r.stdout.trim())
+        return null;
+    const first = r.stdout
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .find((s) => s.length > 0);
+    if (!first)
+        return null;
+    try {
+        if (fs.existsSync(first))
+            return first;
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+/** Known portable-install locations, checked in order (documented fallback). */
+function findGhKnownPaths() {
+    const home = nodeOs.homedir();
+    const candidates = [nodePath.join(home, "tools", "gh", "bin", "gh.exe")];
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c))
+                return c;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
+/** Resolve the gh executable (absolute path): PATH first, then known portable install; null if absent. */
+async function resolveGh() {
+    const onPath = await findGhOnPath();
+    if (onPath)
+        return onPath;
+    return findGhKnownPaths();
+}
+/** The repo context for all gh_* tools: the server process's current working directory. */
+function ghCwd() {
+    return process.cwd();
+}
+/** Detail text for a non-zero exit: stderr first, then stdout, then the exit code. */
+function detail(out) {
+    return out.stderr.trim() || out.stdout.trim() || `gh exited with code ${out.code}`;
+}
+// ---------------------------------------------------------------- gh_auth
+export async function handleGhAuth() {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    try {
+        const st = await runCmd(ghBin, ["auth", "status"], dir);
+        if (st.code === 0) {
+            return JSON.stringify({ success: true, message: "Already authenticated with GitHub." });
+        }
+        // Not authenticated: open a detached terminal window for interactive login,
+        // exactly as the reference does. The window is spawned detached with ignored
+        // stdio so it outlives this call; cmd /k keeps it open for the user.
+        // The resolved absolute gh path is used so the window works even when gh is
+        // not on the server process's PATH.
+        const escapedDir = dir.replace(/"/g, '""');
+        const shellCommand = `start "" /D "${escapedDir}" cmd.exe /k "${ghBin} auth login --git-protocol=https & exit"`;
+        try {
+            spawn("cmd.exe", ["/c", shellCommand], { detached: true, stdio: "ignore", cwd: dir });
+        }
+        catch (e) {
+            return JSON.stringify({
+                error: `Auth check failed: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+        return JSON.stringify({
+            success: true,
+            message: "Opened a terminal window for GitHub authentication. Please sign in there.",
+        });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Auth check failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ----------------------------------------------------------- gh_create_issue
+export async function handleGhCreateIssue(title, body, labels) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    try {
+        let tempFilePath = "";
+        const ghArgs = ["issue", "create", "--title", title];
+        if (body) {
+            tempFilePath = nodePath.join(dir, `gh_issue_body_${Date.now()}.md`);
+            fs.writeFileSync(tempFilePath, body, "utf-8");
+            ghArgs.push("--body-file", tempFilePath);
+        }
+        if (labels) {
+            for (const label of labels) {
+                ghArgs.push("-l", label);
+            }
+        }
+        const out = await runCmd(ghBin, ghArgs, dir);
+        if (tempFilePath) {
+            try {
+                fs.rmSync(tempFilePath, { force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+        if (out.code === 0)
+            return JSON.stringify({ success: true, url: out.stdout.trim() });
+        return JSON.stringify({ error: `Failed to create issue: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Create issue failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ------------------------------------------------------------ gh_list_issues
+export async function handleGhListIssues(state, labels, limit) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    const st = state ?? "open";
+    const lim = typeof limit === "number" && Number.isFinite(limit) && limit >= 1
+        ? Math.min(50, Math.floor(limit))
+        : 10;
+    try {
+        const ghArgs = [
+            "issue",
+            "list",
+            "--state",
+            st,
+            "--limit",
+            String(lim),
+            "--json",
+            "number,title,state,url,labels",
+        ];
+        if (labels) {
+            for (const label of labels) {
+                ghArgs.push("-l", label);
+            }
+        }
+        const out = await runCmd(ghBin, ghArgs, dir);
+        if (out.code === 0) {
+            try {
+                return JSON.stringify({ issues: JSON.parse(out.stdout) });
+            }
+            catch {
+                return JSON.stringify({ error: "Failed to parse issue list output" });
+            }
+        }
+        return JSON.stringify({ error: `List issues failed: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `List issues failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ---------------------------------------------------------- gh_view_comments
+export async function handleGhViewComments(number, type) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    try {
+        // Fallback to standard gh command for reliable JSON parsing of comments
+        const ghArgs = type === "pr"
+            ? ["pr", "view", String(number), "--json", "comments"]
+            : ["issue", "view", String(number), "--json", "comments"];
+        const out = await runCmd(ghBin, ghArgs, dir);
+        if (out.code === 0) {
+            try {
+                const data = JSON.parse(out.stdout);
+                return JSON.stringify({ comments: data.comments || [] });
+            }
+            catch {
+                return JSON.stringify({ raw_output: out.stdout });
+            }
+        }
+        return JSON.stringify({ error: `View comments failed: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `View comments failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ------------------------------------------------------------- gh_create_pr
+export async function handleGhCreatePr(title, body, head_branch, base_branch) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    const base = base_branch || "main";
+    try {
+        let tempFilePath = "";
+        const ghArgs = ["pr", "create", "--title", title, "--head", head_branch, "--base", base];
+        if (body) {
+            tempFilePath = nodePath.join(dir, `gh_pr_body_${Date.now()}.md`);
+            fs.writeFileSync(tempFilePath, body, "utf-8");
+            ghArgs.push("--body-file", tempFilePath);
+        }
+        const out = await runCmd(ghBin, ghArgs, dir);
+        if (tempFilePath) {
+            try {
+                fs.rmSync(tempFilePath, { force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+        if (out.code === 0)
+            return JSON.stringify({ success: true, url: out.stdout.trim() });
+        return JSON.stringify({ error: `Failed to create PR: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Create PR failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// -------------------------------------------------------------- gh_list_prs
+export async function handleGhListPrs(state, limit) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    const st = state ?? "open";
+    const lim = typeof limit === "number" && Number.isFinite(limit) && limit >= 1
+        ? Math.min(50, Math.floor(limit))
+        : 10;
+    try {
+        const ghArgs = [
+            "pr",
+            "list",
+            "--state",
+            st,
+            "--limit",
+            String(lim),
+            "--json",
+            "number,title,state,url,headRefName,baseRefName",
+        ];
+        const out = await runCmd(ghBin, ghArgs, dir);
+        if (out.code === 0) {
+            try {
+                return JSON.stringify({ pull_requests: JSON.parse(out.stdout) });
+            }
+            catch {
+                return JSON.stringify({ error: "Failed to parse PR list output" });
+            }
+        }
+        return JSON.stringify({ error: `List PRs failed: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `List PRs failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ---------------------------------------------------------- gh_view_pr_diff
+export async function handleGhViewPrDiff(number) {
+    const dir = ghCwd();
+    const ghBin = await resolveGh();
+    if (!ghBin)
+        return JSON.stringify({ error: GH_NOT_INSTALLED });
+    try {
+        const out = await runCmd(ghBin, ["pr", "diff", String(number)], dir);
+        if (out.code === 0) {
+            return JSON.stringify({
+                diff: out.stdout.substring(0, 50000) + (out.stdout.length > 50000 ? "\n... (truncated)" : ""),
+            });
+        }
+        return JSON.stringify({ error: `Fetch PR diff failed: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Fetch PR diff failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}
+// ----------------------------------------------------------------- gh_push
+export async function handleGhPush(branch) {
+    const dir = ghCwd();
+    try {
+        const gitArgs = ["push", "origin"];
+        if (branch)
+            gitArgs.push(branch);
+        const out = await runCmd("git", gitArgs, dir);
+        if (out.code === 0)
+            return JSON.stringify({ success: true, message: "Pushed successfully." });
+        return JSON.stringify({ error: `Git push failed: ${detail(out)}` });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Git push failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}

package/dist/gh/schema.js

@@ -0,0 +1,36 @@
+// gh/schema.ts — argument schemas for the 8 gh_* tools.
+// (MCP filesystem fork; thin gh CLI wrappers that operate against the repo at the
+// server process's current working directory — no working-directory parameter, same
+// "current working directory context" as the git/shell tools.)
+import { z } from "zod";
+export const GhAuthArgsSchema = z.object({});
+export const GhCreateIssueArgsSchema = z.object({
+    title: z.string(),
+    body: z.string().optional(),
+    labels: z.array(z.string()).optional(),
+});
+export const GhListIssuesArgsSchema = z.object({
+    state: z.enum(["open", "closed"]).optional().default("open"),
+    labels: z.array(z.string()).optional(),
+    limit: z.number().min(1).max(50).optional().default(10),
+});
+export const GhViewCommentsArgsSchema = z.object({
+    number: z.number().describe("The issue or PR number"),
+    type: z.enum(["issue", "pr"]).default("issue").describe("Whether it's an issue or a pull request"),
+});
+export const GhCreatePrArgsSchema = z.object({
+    title: z.string(),
+    body: z.string().optional(),
+    head_branch: z.string().describe("The branch containing your changes"),
+    base_branch: z.string().default("main").describe("The branch you want to merge into (e.g., main, master)"),
+});
+export const GhListPrsArgsSchema = z.object({
+    state: z.enum(["open", "closed"]).optional().default("open"),
+    limit: z.number().min(1).max(50).optional().default(10),
+});
+export const GhViewPrDiffArgsSchema = z.object({
+    number: z.number().describe("The PR number"),
+});
+export const GhPushArgsSchema = z.object({
+    branch: z.string().optional().describe("Optional: The branch to push. Defaults to current branch."),
+});

package/dist/git/handler.js

@@ -0,0 +1,209 @@
+// git/handler.ts — git CLI wrappers for the 6 git_* tools (MCP filesystem fork).
+//
+// Design: spawn the `git` binary directly (git is on PATH; no new dependency).
+// Every tool operates against the repo at the server process's current working
+// directory (process.cwd()) — the same "current working directory context" the
+// shell tools use — and takes NO working-directory parameter (matching the
+// reference Beledarian tools). Path arguments are resolved relative to that
+// directory. All argument values (messages, branch names, file paths) are passed
+// as individual argv elements (no shell), so quotes / Unicode / special
+// characters pass through verbatim.
+//
+// Return shape mirrors the reference implementation: each handler returns a JSON
+// text string carrying the reference's fields ({error} on failure, {diff},
+// {history}, {success, ...}) instead of throwing, so a working directory that is
+// not inside a git repository yields a clear error string rather than a crash.
+import { spawn } from "child_process";
+import nodePath from "path";
+/** Run `git <args>` with the given cwd. Never rejects; spawn failures resolve with code -1. */
+function runGit(args, cwd) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn("git", args, { cwd });
+        }
+        catch (e) {
+            resolve({ code: -1, stdout: "", stderr: e instanceof Error ? e.message : String(e) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code, stdout, stderr });
+        };
+        if (child.stdout) {
+            child.stdout.on("data", (d) => {
+                stdout += d.toString("utf8");
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on("data", (d) => {
+                stderr += d.toString("utf8");
+            });
+        }
+        child.on("error", (e) => {
+            // e.g. ENOENT when the git binary cannot be found on PATH
+            stderr += (stderr ? "\n" : "") + (e.message || String(e));
+            finish(-1);
+        });
+        child.on("close", (code) => finish(code === null ? -1 : code));
+    });
+}
+/** JSON error text matching the reference shape: {error: "Git <what> failed: <detail>"}. */
+function failText(out, what) {
+    const detail = out.stderr.trim() || out.stdout.trim() || `git exited with code ${out.code}`;
+    return JSON.stringify({ error: `Git ${what} failed: ${detail}` });
+}
+/** The repo context for all git_* tools: the server process's current working directory. */
+function gitCwd() {
+    return process.cwd();
+}
+export async function handleGitStatus() {
+    const dir = gitCwd();
+    const st = await runGit(["status", "--porcelain=v1", "--branch"], dir);
+    if (st.code !== 0) {
+        return failText(st, "status");
+    }
+    const lines = st.stdout.replace(/\r/g, "").split("\n");
+    let current = null;
+    let tracking = null;
+    let ahead = 0;
+    let behind = 0;
+    const staged = [];
+    const notStaged = [];
+    const untracked = [];
+    const files = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (i === 0 && line.startsWith("## ")) {
+            // Header: "## branch", "## branch...upstream", "## branch...upstream [ahead 1, behind 2]",
+            // or "## HEAD (no branch)" (detached HEAD).
+            let rest = line.slice(3);
+            const bracket = / \[([^\]]*)\]$/.exec(rest);
+            if (bracket) {
+                const am = /ahead (\d+)/.exec(bracket[1]);
+                const bm = /behind (\d+)/.exec(bracket[1]);
+                if (am)
+                    ahead = parseInt(am[1], 10);
+                if (bm)
+                    behind = parseInt(bm[1], 10);
+                rest = rest.slice(0, rest.length - bracket[0].length);
+            }
+            const sep = rest.indexOf("...");
+            if (sep >= 0) {
+                const left = rest.slice(0, sep);
+                current = left === "HEAD" ? null : left;
+                tracking = rest.slice(sep + 3) || null;
+            }
+            else if (rest.startsWith("HEAD (")) {
+                current = null;
+                tracking = null;
+            }
+            else {
+                current = rest || null;
+                tracking = null;
+            }
+            continue;
+        }
+        if (!line)
+            continue;
+        const index = line[0];
+        const working = line[1];
+        let p = line.slice(3);
+        // Rename/copy entries: "R  old -> new" / "C  old -> new" — report the destination.
+        if (index === "R" || index === "C") {
+            const arrow = p.indexOf(" -> ");
+            if (arrow >= 0)
+                p = p.slice(arrow + 4);
+        }
+        files.push({ path: p, index, working_dir: working });
+        if (index === "?" && working === "?") {
+            untracked.push(p);
+        }
+        else {
+            if (index !== " " && index !== "?")
+                staged.push(p);
+            if (working !== " " && working !== "?")
+                notStaged.push(p);
+        }
+    }
+    const isClean = staged.length === 0 && notStaged.length === 0 && untracked.length === 0;
+    return JSON.stringify({ current, tracking, ahead, behind, isClean, staged, notStaged, untracked, files });
+}
+export async function handleGitDiff(file_path, cached) {
+    const dir = gitCwd();
+    const args = ["diff"];
+    if (cached)
+        args.push("--cached");
+    if (file_path) {
+        args.push("--", nodePath.resolve(dir, file_path));
+    }
+    const d = await runGit(args, dir);
+    if (d.code !== 0) {
+        return failText(d, "diff");
+    }
+    const text = d.stdout.replace(/\n$/, "");
+    return JSON.stringify({ diff: text.length > 0 ? text : "No changes." });
+}
+export async function handleGitCommit(message) {
+    const dir = gitCwd();
+    // Pre-image stat of what is staged (mirrors the reference's {changed, insertions, deletions} summary).
+    const summary = { changed: 0, insertions: 0, deletions: 0 };
+    const pre = await runGit(["diff", "--cached", "--shortstat"], dir);
+    if (pre.code === 0 && pre.stdout.trim()) {
+        const mf = /(\d+) files? changed/.exec(pre.stdout);
+        if (mf)
+            summary.changed = parseInt(mf[1], 10);
+        const mi = /(\d+) insertions?\(\+\)/.exec(pre.stdout);
+        if (mi)
+            summary.insertions = parseInt(mi[1], 10);
+        const md = /(\d+) deletions?\(-\)/.exec(pre.stdout);
+        if (md)
+            summary.deletions = parseInt(md[1], 10);
+    }
+    // Standard git behavior: commit only what is staged.
+    const c = await runGit(["commit", "-m", message], dir);
+    if (c.code !== 0) {
+        return failText(c, "commit");
+    }
+    return JSON.stringify({ success: true, summary });
+}
+export async function handleGitLog(max_count) {
+    const dir = gitCwd();
+    const n = typeof max_count === "number" && Number.isFinite(max_count) && max_count > 0
+        ? Math.floor(max_count)
+        : 10;
+    const l = await runGit(["log", "-n", String(n), "--pretty=format:%h %s (%an, %ar)"], dir);
+    if (l.code !== 0) {
+        return failText(l, "log");
+    }
+    const history = l.stdout
+        .split("\n")
+        .map((s) => s.trimEnd())
+        .filter((s) => s.length > 0);
+    return JSON.stringify({ history });
+}
+export async function handleGitAdd(paths) {
+    const dir = gitCwd();
+    const args = paths && paths.length > 0
+        ? ["add", "--", ...paths.map((p) => nodePath.resolve(dir, p))]
+        : ["add", "."];
+    const a = await runGit(args, dir);
+    if (a.code !== 0) {
+        return failText(a, "add");
+    }
+    return JSON.stringify({ success: true, message: "Files staged successfully." });
+}
+export async function handleGitCheckout(branch_name, create_new) {
+    const dir = gitCwd();
+    const args = create_new ? ["checkout", "-b", branch_name] : ["checkout", branch_name];
+    const c = await runGit(args, dir);
+    if (c.code !== 0) {
+        return failText(c, "checkout");
+    }
+    return JSON.stringify({ success: true, message: `Switched to branch '${branch_name}'.` });
+}

package/dist/git/schema.js

@@ -0,0 +1,23 @@
+// git/schema.ts — argument schemas for the 6 git_* tools.
+// (MCP filesystem fork; thin git CLI wrappers that operate against the repo at the
+// server process's current working directory — no working-directory parameter, same
+// "current working directory context" as the shell tools.)
+import { z } from "zod";
+export const GitStatusArgsSchema = z.object({});
+export const GitDiffArgsSchema = z.object({
+    file_path: z.string().optional().describe("Optional: Path to specific file to diff."),
+    cached: z.boolean().optional().describe("Optional: Show staged changes only (git diff --cached)."),
+});
+export const GitCommitArgsSchema = z.object({
+    message: z.string(),
+});
+export const GitLogArgsSchema = z.object({
+    max_count: z.number().optional().describe("Max number of commits to return (default: 10)"),
+});
+export const GitAddArgsSchema = z.object({
+    paths: z.array(z.string()).optional().describe("Optional: Specific file paths to stage. If omitted, stages all changes."),
+});
+export const GitCheckoutArgsSchema = z.object({
+    branch_name: z.string().describe("Name of the branch to checkout."),
+    create_new: z.boolean().optional().default(false).describe("If true, creates the branch if it doesn't exist (like git checkout -b)."),
+});

package/dist/launch_file/handler.js

@@ -51,7 +51,9 @@ const URI_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]+:/;
  * Only the opener executable changes; the target still passes the full
  * URL/path policy below.
  */
-function openerPath() {
+// Exported (v0.2.23) so the system tools (preview_html) can reuse the exact
+// same opener resolution — no behavior change.
+export function openerPath() {
     if (process.platform !== "win32") {
         throw new Error("launch_file is supported only on Windows");
     }