Branchline MCP Connector

Why Branchline

Your Git client should make changes easier to understand. Your AI assistant should make its next action easier to review.

Branchline brings both into one macOS app: a focused Git workspace inspired by familiar IDE workflows, and a local MCP connector that asks for your approval before executing an AI's command. Built with Tauri 2, Rust, and TypeScript, with a compact interface, local assets, and a dark theme you can tune to your eyes.

Related MCP server: DPR MCP Server

AI workflows with a human decision

Plan → review → approve or deny → execute → report the result.

Connect an AI client once through AI requests → Settings. The onboarding guide provides the MCP setup fields or commands for your client and optional skill installation. Connections work across local repositories; each request identifies its own target.

An assistant can request a complete workflow, for example:

git add -- src/policy.rs &&
git commit -m "Record approval decisions in activity history" &&
git push --set-upstream origin feat/activity-history &&
gh pr create \
  --title "Record approval decisions in activity history" \
  --body "Keep command outcomes and approval decisions together." \
  --head feat/activity-history \
  --base main

Branchline preserves the command as written. Recognized operations receive structured review cards; stage and commit cards can open read-only file diffs. Publishing to a primary branch or pushing between differently named branches is highlighted when detected. Runtime expressions and unsupported preview syntax remain explicit uncertainties, with the exact command available to inspect.

Approval covers the whole command, including its shell control flow. There is no partial-approval mode, and MCP has no approval endpoint. The user makes the decision in Branchline; the AI waits and reports the actual recorded outcome.

Manual review is the default. You can opt into session-limited auto-approval for selected actions or all requests from one connection, scoped to a chosen repository or all repositories. Review and confirm each rule in the app, and pause it at any time. Rules are not restored after quitting Branchline; broad session rules may run destructive commands and scripts.

A permission gate, not a sandbox. Approved commands run noninteractively as your user account and may invoke Git hooks, credential helpers, shell programs, or GitHub CLI extensions. A successful exit confirms process success, not independently verified effects. Background or deliberately detached work can outlive the shell or its timeout. Inspect state before retrying an interrupted command.

Command output is withheld from durable receipts because it may contain secrets. Exact command inputs are retained locally, so keep credentials out of arguments and standard input. Optional source-diff access is a separate connection setting. See the connector guide for setup, privacy, and execution limits.

A focused Git workspace

• Review and commit. Open a repository, select a file, inspect its diff, stage individual hunks or whole files, and commit the staged result. Stale snapshots are checked before sensitive operations.

• Navigate history. Browse a commit graph, search loaded history, inspect historical files, and use contextual actions to squash, reword, cherry-pick, revert, or branch from a commit. History rewrites have safety checks and recovery refs.

• Work with branches and remotes. Search cached branches, switch, create, rename, or push a branch. Update fetches and fast-forwards; its menu offers fetch without pulling.

• Make room for the task. Resize or collapse the files, log, and diff panels. Open repositories in separate windows. Adjust interface text, code size, spacing, and contrast.

• Keep the view current. Local repository changes refresh automatically, with selection and scrolling preserved. Automatic refresh does not fetch or pull.

Install on macOS

On an Apple Silicon Mac running macOS 12 or later:

curl -fsSL https://raw.githubusercontent.com/ShindouMihou/branchline/main/scripts/install.sh | bash

The installer downloads the latest GitHub release, verifies its SHA-256 checksum, checks the app bundle identity and signature, and installs to ~/Applications/Branchline.app. It requires no sudo and preserves an existing copy if replacement fails. Quit the Branchline GUI before updating.

Prefer to inspect the script first? Read the installer, or download the app archive and checksum from Releases. The current preview is ad-hoc signed and not notarized. The installer does not remove quarantine attributes or bypass macOS security policy.

Optional settings:

curl -fsSL https://raw.githubusercontent.com/ShindouMihou/branchline/main/scripts/install.sh | \
  BRANCHLINE_VERSION=v0.4.4 BRANCHLINE_INSTALL_DIR="$HOME/Applications" bash

App updates

Updater-enabled builds check for new releases quietly and let you install and restart from inside Branchline. Use Branchline → Check for Updates… or Appearance → App updates. Users on 0.4.2 or earlier need one manual upgrade to receive this feature. See in-app updates and signed release preparation.

Run locally

Branchline is in active development. Apple Silicon macOS is the currently packaged and tested target. Windows and Linux builds have not been verified. Locally generated macOS bundles are ad-hoc signed and are not notarized.

You will need Node.js 22+, npm, stable Rust, Xcode Command Line Tools, and Git. Install and authenticate GitHub CLI for workflows that use gh.

git clone https://github.com/ShindouMihou/branchline.git
cd branchline
npm ci
npm run desktop

Build a macOS app bundle:

npm run tauri -- build

The bundle is written to src-tauri/target/release/bundle/macos/Branchline.app.

Checks

npm test
npm run build
npm run test:installer
cargo test --manifest-path src-tauri/Cargo.toml

The current suite has 158 Rust tests, 63 frontend tests, and 11 installer checks. Additional blind testing covers command execution, structured previews, approval ownership, denial, timeouts, cancellation, and result integrity. After a release build, run the eight packaged MCP protocol checks with:

node scripts/test-mcp-wire.mjs

The blind-test report distinguishes real local Git tests from offline GitHub fixtures and records the limits those tests established.

Project structure

src/          TypeScript interface, diff rendering, syntax, and interaction tests
src-tauri/    Rust Git services, MCP broker, approval lifecycle, and native app
assets/       Original brand assets and attributed provider icons
docs/         User guides, connector design, command coverage, and test reports
scripts/      Development launcher and packaged MCP protocol checks

The frontend is framework-free TypeScript. Rust owns repository operations and command execution. Syntax highlighting uses Shiki, and UI icons use Lucide. Dependencies, generated bundles, local toolchains, and runtime credentials are excluded from the repository.

Documentation

• Installation — one-line installer, checksums, and platform support

• User guide — staging, history, branches, recovery, and appearance

• MCP connector — setup, skills, waiting, privacy, and execution limits

• Composable command workflows — whole-command approval model

• Command coverage — execution support versus structured previews

• Blind testing — scenarios, findings, and verified limits

• Validation notes — implementation checks and regression history

• Visual design — layout, palette, and original brand assets

Contributing

Bug reports, reproducible examples, and focused pull requests are welcome. For approval or execution changes, include a disposable-repository regression test and state what happens before approval, after denial, and on failure. Keep uncertainty visible: a preview should never imply that it understands effects it cannot verify.

Please do not include credentials, private repository contents, or personal activity exports in issues or screenshots. See CONTRIBUTING.md for the development workflow.

License

Apache License 2.0. Provider glyphs retain their original MIT license and attribution. See NOTICE.