ChatCut WorkBuddy install guide

This plain text version is returned because this request does not look like a browser page navigation.
Browser page: https://chatcut.io/workbuddy

Full installation guide:

This installs the ChatCut MCP server for **WorkBuddy** (Tencent Cloud CodeBuddy). It connects to the hosted ChatCut Cloud MCP server.

WorkBuddy's remote MCP servers authenticate with a **static `Authorization: Bearer` header** - there is no built-in OAuth login command, so you obtain the token with the manual OAuth 2.0 flow below and paste it into WorkBuddy's MCP settings.

The commands work from macOS, Linux, and Windows terminals as long as `curl` and `python3` are available in `PATH`.

## Prerequisites

Before installing, verify these commands are available:

```text
curl --version
python3 --version
```

`curl` and `python3` must be visible in `PATH`. They are used for the OAuth client registration, token exchange, and MCP verification steps below.

On Windows, use PowerShell, Command Prompt, Windows Terminal, or WSL; the commands below are the same.

## Install

If you are a WorkBuddy agent reading this file for a user, set up the ChatCut MCP server for them. Do not only describe these commands; run them when the user has asked you to set up ChatCut.

WorkBuddy has no built-in `mcp login` command, so complete the OAuth 2.0 flow manually. This guide uses the local callback port **52961** for WorkBuddy.

### 1. Register an OAuth client

Register your own OAuth client via Dynamic Client Registration. This returns a `client_id` bound to WorkBuddy's callback port - your own client, not shared with other editors:

```bash
curl -s -X POST "https://<CHATCUT_HOST>/auth/mcp/register" \
  -H "Content-Type: application/json" \
  -d '{
    "client_name": "workbuddy",
    "redirect_uris": ["http://127.0.0.1:52961/callback"],
    "grant_types": ["authorization_code", "refresh_token"],
    "response_types": ["code"],
    "token_endpoint_auth_method": "none",
    "scope": "openid profile email offline_access"
  }'
```

Save the `client_id` from the response. Use it as `<CLIENT_ID>` below.

### 2. Generate PKCE parameters

```bash
python3 -c "
import secrets, hashlib, base64
verifier = base64.urlsafe_b64encode(secrets.token_bytes(32)).rstrip(b'=').decode()
challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).rstrip(b'=').decode()
print(f'VERIFIER={verifier}')
print(f'CHALLENGE={challenge}')
"
```

Save both values. You will need them below.

### 3. Authorize

Run this single command. It **opens the authorization page in your browser automatically**, then captures the returned code on WorkBuddy's port 52961. Replace `<CLIENT_ID>` and `<CHALLENGE>`:

```bash
python3 -c "
import http.server, socketserver, urllib.parse, webbrowser
URL = 'https://<CHATCUT_HOST>/auth/mcp/authorize?response_type=code&client_id=<CLIENT_ID>&code_challenge=<CHALLENGE>&code_challenge_method=S256&redirect_uri=http://127.0.0.1:52961/callback&scope=openid+profile+email+offline_access&state=chatcut'
captured = {}
class H(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
        if 'code' in q:
            captured['code'] = q['code'][0]
            self.send_response(200); self.end_headers()
            self.wfile.write(b'ChatCut authorized - you can close this tab.')
    def log_message(*a): pass
with socketserver.TCPServer(('127.0.0.1', 52961), H) as s:
    s.timeout = 1
    webbrowser.open(URL)
    print('Opened the authorization page. Log in and click Allow ChatCut...')
    for _ in range(180):
        s.handle_request()
        if 'code' in captured: break
print('CODE=' + captured.get('code', '(timed out - copy the URL above and open it manually)'))
"
```

The browser opens to the ChatCut sign-in page. Log in and click "Allow ChatCut"; the command then prints `CODE=...`. If the browser did not open automatically, copy the `URL` value from the command and open it manually.

### 4. Exchange the code for an access token

```bash
curl -s -X POST "https://<CHATCUT_HOST>/auth/mcp/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code" \
  -d "code=<AUTHORIZATION_CODE>" \
  -d "redirect_uri=http://127.0.0.1:52961/callback" \
  -d "client_id=<CLIENT_ID>" \
  -d "code_verifier=<VERIFIER>"
```

The response contains `access_token` (expires in ~1 hour), `refresh_token`, and `expires_in`.

Do not restart yet. Complete the configuration and verification steps below first.

## Configure

Add the ChatCut MCP server to WorkBuddy's MCP config file:

```text
~/.workbuddy/mcp.json
```

> **Important - use exactly `mcp.json`, with NO leading dot.** This is the exact path WorkBuddy shows on its **MCP settings** page. Do not create `~/.workbuddy/.mcp.json` (with a dot) or any other variant - WorkBuddy reads `~/.workbuddy/mcp.json`. Writing to the wrong filename is the most common reason the `chatcut` server never shows up.

Add the `chatcut` server as an **HTTP** type, pasting the access token into the `Authorization` header (replace `<access_token>`). If the file already has an `mcpServers` object, merge this entry into it rather than overwriting:

```json
{
  "mcpServers": {
    "chatcut": {
      "type": "http",
      "url": "https://<CHATCUT_HOST>/api/external-mcp/mcp",
      "headers": {
        "Authorization": "Bearer <access_token>"
      }
    }
  }
}
```

Save the file, then restart WorkBuddy (or start a new session) so it loads the new server.

## Verify

Verify the MCP Server responds:

```bash
curl -s -X POST "https://<CHATCUT_HOST>/api/external-mcp/mcp" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer <access_token>" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"workbuddy","version":"1.0.0"}}}'
```

A successful response returns server capabilities and tool definitions.

Also verify that ChatCut tools appear in WorkBuddy. Start a new conversation - the current session cannot pick up newly configured MCP tools.

If the MCP server is found but requests return "Unauthorized", the access token has expired (~1 hour). Refresh it:

```bash
curl -s -X POST "https://<CHATCUT_HOST>/auth/mcp/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=refresh_token" \
  -d "refresh_token=<REFRESH_TOKEN>" \
  -d "client_id=<CLIENT_ID>"
```

Update the `Authorization` header in WorkBuddy's MCP settings with the new `access_token`. If the refresh token has also expired, rerun the OAuth flow from Step 2.

## Start Editing

After restarting WorkBuddy if needed, give the user the resolved startup prompt below and ask them to paste it into a new WorkBuddy conversation.

Resolve `startupPromptLanguage` from the user's actual conversation language, not the operating system language. Do not ask the user to choose. Generate the startup prompt in `startupPromptLanguage` using the exact prompts below; for any other `startupPromptLanguage`, translate the English one.

```text
Chinese:
ChatCut 插件已经安装好了，请你用内置浏览器打开一个 ChatCut 项目，把项目名称命名为“我的第一个ChatCut视频”，然后先告诉我你整体可以做什么，尤其是这三部分：视频剪辑（语音清理、字幕、转场、补充素材等）、MG 动画制作、素材生成（视频、旁白、音乐、音效等）。之后问我有什么素材、想做什么样的视频，告诉我你可以根据我的具体需求一步步开始制作，并且我也可以随时进入 ChatCut 编辑界面自己调整时间线、字幕、MG 动画等任何内容，就像使用传统编辑器一样。

English:
The ChatCut plugin is already installed. Please use the built-in browser to open a ChatCut project, name the project "My First ChatCut Video", then first tell me an overall view of what you can do, especially these three parts —— video editing(speech cleanup, caption, transition, b-roll, etc), motion graphics creation, assets generation(video, voiceover, music, sound effects, etc). After that, ask me what materials I have and what kind of video I want to make. Tell me you can start making it step by step based on my specific needs and I can also hop into the ChatCut editing interface anytime and adjust things by myself, timeline, captions, motion graphics, anything, just like a traditional editor.

Spanish:
El plugin de ChatCut ya está instalado. Usa el navegador integrado para abrir un proyecto de ChatCut, nombra el proyecto "Mi primer video de ChatCut" y luego primero dame una visión general de lo que puedes hacer, especialmente estas tres partes: edición de video (limpieza de voz, subtítulos, transiciones, b-roll, etc.), creación de motion graphics y generación de recursos (video, voz en off, música, efectos de sonido, etc.). Después pregúntame qué materiales tengo y qué tipo de video quiero crear. Dime que puedes empezar a crearlo paso a paso según mis necesidades concretas y que también puedo entrar en la interfaz de edición de ChatCut en cualquier momento para ajustar cosas por mi cuenta, como la línea de tiempo, los subtítulos, los motion graphics o cualquier otro elemento, igual que en un editor tradicional.
```

## ChatCut Skills (Playbooks)

ChatCut ships editing playbooks (talking-head, motion graphics, image/video/voice/music generation, and more) through the MCP connection itself - there is nothing extra to install. Before a non-trivial editing or generation task, have the agent call `list_skills` to see the catalog, then `load_skill({ name })` to load the matching playbook and follow it. These are the same playbooks ChatCut's in-product agent uses, and they update with every ChatCut backend deploy (no reinstall needed).

## Update

To change the MCP server URL or token later, edit the ChatCut entry in WorkBuddy's MCP settings. To refresh an expired token, use the refresh command in [Verify](#verify).