DEV Community: zhensherlock

Protocol Launcher Series: One-Click Telegram Chats and Channels

zhensherlock — Mon, 23 Mar 2026 12:01:44 +0000

After introducing one-click configuration for JetBrains, today we shift our focus from development environments to an instant messaging platform — Telegram.

With Protocol Launcher, you can generate type-safe deep links for Telegram so users can, from web pages, consoles, or automation scripts, open the client and jump to a specific username or channel in one click — delivering a “single tap to chat” experience.

Telegram and Deep Links

Telegram is a cloud-based messaging platform that supports multi-device sync, channels, bots, group collaboration, and more. It provides official URL schemes (such as tg:// and https://t.me/...) that allow external applications to open the client or navigate to specific resources directly.

If you want to guide users from a website, admin panel, or embedded product page to:

Open the Telegram client
Visit a particular username, channel, or bot home page

the traditional approach usually involves hand-writing links, dealing with URL encoding, and validating compatibility across multiple platforms. Protocol Launcher wraps all these details into simple function calls and significantly reduces the chance of errors.

Core Capabilities: One-Click Open and Precise Navigation

Protocol Launcher provides a dedicated protocol-launcher/telegram submodule for Telegram with the following core capabilities:

Open the Telegram client: Use the open function to quickly launch the local Telegram app.
Jump to a specific username/channel: Use the openDomain function to navigate to a specific username, channel, or bot.
Tree-shakable and full imports: Support both subpath, on-demand imports and root-level unified imports.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the Telegram module on demand
import { open, openDomain } from 'protocol-launcher/telegram'

// You can also import from the root package, but this will include all app modules
// import { telegram } from 'protocol-launcher'

Scenario 1: Open the Telegram Client from the Web (`open`)

On your website, login help page, or “Contact Support” section, you can provide an “Open Telegram” button that switches users directly to the local Telegram client:

import { open } from 'protocol-launcher/telegram'

const url = open()

Bind the generated URL to a button or link and you get a seamless jump from the browser to Telegram.

Scenario 2: Jump to a Specific Username or Channel (`openDomain`)

When you want users to join a channel, follow an account, or start using a bot, you can use openDomain to generate a direct link:

import { openDomain } from 'protocol-launcher/telegram'

const url = openDomain({
  domain: 'zhensherlock', // Telegram username, channel name, or bot name
})

This link can be used to:

Configure a “Join Telegram Channel” button inside your product
Generate invitation links in your operations/admin console
Guide users to follow an official account in your documentation center

Why Protocol Launcher?

Automatic encoding and protocol encapsulation: The library generates valid deep links based on Telegram’s protocol rules, avoiding missing parameters or encoding mistakes that often occur with handwritten URLs.
Type safety and parameter hints: TypeScript support provides IntelliSense for the domain field in openDomain, reducing the risk of typos.
Extreme tree shaking: A modular design supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports such as import { open } from 'protocol-launcher/telegram'.
- Full import: You can also import unified entry points from the root package, such as import { telegram } from 'protocol-launcher', which is convenient for quick scripts or demos.
Cross-platform consistency: Deep link generation logic can be reused across different runtime environments, helping maintain a consistent experience on the web, desktop, and local tools.

Conclusion

With Protocol Launcher, you can easily weave Telegram into your product’s user journey. From simply “opening the client” to jumping directly to a specific channel or username, everything can be done with just a few lines of type-safe code, helping users reach your communication entry points with minimal friction.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app/
Telegram Module Docs: Telegram | Protocol Launcher

Protocol Launcher Series: One-Click Launch for IntelliJ IDEA and JetBrains IDEs

zhensherlock — Tue, 10 Mar 2026 15:23:55 +0000

After introducing one-click configuration for CodeBuddy, today we turn to one of the most common tools in enterprise development — the JetBrains IDE family, with a focus on IntelliJ IDEA.

With Protocol Launcher, you can generate deep links for IntelliJ IDEA and other JetBrains IDEs such as GoLand, PhpStorm, PyCharm, RustRover, and WebStorm in a type-safe way, enabling projects and files to be opened directly from web pages, CLIs, or internal platforms.

IntelliJ IDEA and Deep Links

IntelliJ IDEA is one of the most popular IDEs for JVM and multi-language development, widely used for enterprise backends, desktop applications, and multi-module projects.

With Protocol Launcher, you can build on top of protocols such as idea:// to:

Open a specific project or module directory directly in the local IDEA instance.
Navigate precisely to a particular source file at a specific line and column.

Core Capability: Unified Project Launch Across IDEs

Protocol Launcher provides a dedicated protocol-launcher/idea submodule for IntelliJ IDEA, as well as corresponding submodules for other JetBrains IDEs:

protocol-launcher/idea: IntelliJ IDEA
protocol-launcher/goland: GoLand
protocol-launcher/phpstorm: PhpStorm
protocol-launcher/pycharm: PyCharm
protocol-launcher/rustrover: RustRover
protocol-launcher/webstorm: WebStorm

They share a unified set of core capabilities:

Precise file opening: Specify file path, line, and column.
Open projects/workspaces: Open local project roots or arbitrary folders with one call.
Tree-shakable and full imports: Support both tree-shaking-friendly subpath imports and convenient root-level imports.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the IntelliJ IDEA module on demand
import { openFile, openFolder } from 'protocol-launcher/idea'

// You can also import from the root package, but this will include all app modules
// import { idea } from 'protocol-launcher'

Scenario 1: Precisely Open a File in IntelliJ IDEA (`openFile`)

On a web error page or internal platform, you can provide an “Open in IntelliJ IDEA” button that jumps directly to the local source location:

import { openFile } from 'protocol-launcher/idea'

const url = openFile({
  path: '/Users/dev/project/src/main/java/com/example/App.java', // Absolute path to the file
  line: 42, // Optional: jump to line 42
  column: 5, // Optional: jump to column 5
})

Scenario 2: Open a Project or Module Root (`openFolder`)

After a scaffolding or automation script finishes project initialization, you can automatically open the project directory in IntelliJ IDEA:

import { openFolder } from 'protocol-launcher/idea'

const url = openFolder({
  path: '/Users/dev/project', // Absolute path to the folder
})

Reusing the Same Logic Across Other JetBrains IDEs

Even more valuable is that the logic you design for IntelliJ IDEA can almost be copied verbatim to other JetBrains IDEs by simply changing the import path:

// Open a Go project file in GoLand
import { openFile as openGoFile } from 'protocol-launcher/goland'

const goUrl = openGoFile({
  path: '/Users/dev/go-project/main.go', // Absolute path to the file
  line: 10, // Optional: jump to line 10
  column: 1, // Optional: jump to column 1
})

// Open a Python project root directory in PyCharm
import { openFolder as openPyFolder } from 'protocol-launcher/pycharm'

const pyUrl = openPyFolder({
  path: '/Users/dev/python-project',
})

In this way, you can provide unified, intuitive “Open in the corresponding IDE” buttons for teams working with different tech stacks on your internal platforms or documentation systems.

Why Protocol Launcher?

Automatic encoding and path compatibility: Handles spaces, special characters, and Unicode in file paths so deep links are parsed correctly on macOS, Windows, and other systems.
Type safety and smart hints: With TypeScript, you get full type hints for path, line, column, and other parameters, avoiding low-level errors commonly introduced by string concatenation.
Extreme tree shaking: A modular design supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports such as import { openFile } from 'protocol-launcher/idea' or 'protocol-launcher/goland'.
- Full import: You can also import unified entry points from the root package, such as import { idea, goland } from 'protocol-launcher', which is convenient for quick scripts or demos.

Conclusion

With Protocol Launcher, you can build a unified “one-click jump from web/CLI to local IDE” experience for IntelliJ IDEA and the entire JetBrains family. Whether it’s error log navigation, code review, scaffolding-generated projects, or navigation entries in internal platforms, you can offer smooth workflows to developers at a much lower cost.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
IntelliJ IDEA Module Docs: IntelliJ IDEA | Protocol Launcher
GoLand Module Docs: GoLand | Protocol Launcher
PhpStorm Module Docs: PhpStorm | Protocol Launcher
PyCharm Module Docs: PyCharm | Protocol Launcher
RustRover Module Docs: RustRover | Protocol Launcher
WebStorm Module Docs: WebStorm | Protocol Launcher

Protocol Launcher Series: One-Click CodeBuddy Development Experience

zhensherlock — Thu, 05 Mar 2026 15:13:16 +0000

After introducing one-click configuration for Cursor, today let’s talk about a powerful code editor — CodeBuddy.

As remote development and cloud collaboration become more common, developers need a lightweight way to quickly open projects, inspect code, or connect to remote environments. With Protocol Launcher, you can generate elegant launch links for CodeBuddy and achieve seamless jumps from web pages or automation scripts into the editor.

CodeBuddy and Deep Links

CodeBuddy provides a well-designed deep link protocol. Whether you want to open local files, open directories, or establish remote SSH connections, you can trigger these actions via specific URL schemes.

However, manually composing such links usually means dealing with complex path encoding and subtle differences in how protocols are handled across operating systems.

With Protocol Launcher, you can wrap these operations in type-safe function calls and make app launching both simple and robust.

Core Capabilities: Fast and Versatile

Protocol Launcher provides a dedicated protocol-launcher/code-buddy module for CodeBuddy with the following core features:

Quick editor launch: Start the CodeBuddy client with one click.
Precise file navigation: Open a specific file path and jump to a given line and column.
Folder and workspace management: Open local project folders in one step.
Remote development connections: Use SSH to connect to remote servers with a single link.
Shortcut to settings: Jump directly to the settings interface.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles depending on your scenario:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the CodeBuddy module on demand
import { openFile, openRemote, openFolder } from 'protocol-launcher/code-buddy'

// You can also import from the root package, but this will include all app modules
// import { codeBuddy } from 'protocol-launcher'

Scenario 1: Open a File Precisely (`openFile`)

In code review tools or log analysis systems, you can guide users to view the corresponding code directly in CodeBuddy:

import { openFile } from 'protocol-launcher/code-buddy'

const url = openFile({
  path: '/Users/dev/project/src/index.ts', // Absolute path to the file
  line: 42, // Optional: jump to line 42
  column: 10, // Optional: jump to column 10
  openInNewWindow: true, // Optional: open in a new window
})

Scenario 2: One-Click Remote Environment Connection (`openRemote`)

If you need to guide users to develop on a remote server, you can generate an SSH remote connection link. This greatly simplifies entering remote environments:

import { openRemote } from 'protocol-launcher/code-buddy'

const url = openRemote({
  type: 'ssh-remote', // Remote connection type
  host: 'root@172.18.105.209:22', // Remote host address
  path: '/code/my-project', // Project path
})

Scenario 3: Open a Folder (`openFolder`)

After an automation script finishes running, you can automatically open the generated project directory for the user:

import { openFolder } from 'protocol-launcher/code-buddy'

const url = openFolder({
  path: '/Users/dev/project', // Absolute path to the project or module folder
  openInNewWindow: true, // Optional: open in a new window
})

Why Protocol Launcher?

Automatic encoding and Unicode support: The library automatically handles special characters and Chinese characters in paths, ensuring that generated URLs never become garbled when launching CodeBuddy.
Type safety and completion: TypeScript’s strong typing ensures parameter correctness and helps avoid typos that are easy to make when manually concatenating strings.
Extreme tree shaking: A modular design supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports such as import { openFile } from 'protocol-launcher/code-buddy'.
- Full import: You can also import from the root package, for example import { codeBuddy } from 'protocol-launcher'.
Cross-platform consistency: It abstracts away low-level protocol-triggering differences, ensuring consistent behavior across macOS, Windows, and other systems.

Conclusion

With Protocol Launcher, you can provide CodeBuddy users with a smoother development experience. Whether in web consoles, documentation centers, or automation tools, one-click editor launching can significantly boost developer productivity.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
CodeBuddy Module Docs: CodeBuddy | Protocol Launcher

Protocol Launcher Series: Powering Cursor with MCP Services and AI

zhensherlock — Mon, 02 Mar 2026 02:37:01 +0000

After introducing one-click configuration for GitHub Desktop, today we turn to one of the hottest AI code editors — Cursor.

Cursor has changed how developers write code with its deeply integrated AI capabilities. With Protocol Launcher, you can go even further: automate MCP service configuration and quickly trigger AI chats, making Cursor’s power easier to access.

Cursor and the MCP Protocol

Cursor is an AI-powered editor with full support for the MCP (Model Context Protocol). By connecting MCP services, Cursor can access local files, call external APIs, and even orchestrate complex tools.

However, manually adding an MCP server in Cursor typically means opening the settings UI and repeatedly copying and pasting names, commands, and arguments.

With Protocol Launcher, you can compress this entire configuration flow into a single click and achieve truly “zero-friction” installation.

Core Capabilities: Automated Setup and Smart Interaction

Protocol Launcher provides a dedicated protocol-launcher/cursor module with the following core features:

Automated MCP configuration: One-click installation for multiple transport protocols, including stdio, sse, and streamable_http.
Precise file control: Launch Cursor from external tools and jump to specific files, lines, and columns.
Smart chat triggers: Pre-fill prompts and start Cursor AI chats with one click.
System-level shortcuts: Quickly open settings or manage workspaces.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the Cursor module on demand
import { installMCP, openFile, createChat } from 'protocol-launcher/cursor'

// You can also import from the root package, but this will include all app modules
// import { cursor } from 'protocol-launcher'

Scenario 1: One-Click MCP Service Installation (`installMCP`)

Whether your MCP service runs locally via npx or as a remote SSE endpoint, you can generate an installation link with:

import { installMCP } from 'protocol-launcher/cursor'

// Install a local stdio-based MCP service
const url = installMCP({
  name: 'server-everything', // MCP Server name
  type: 'stdio', // MCP Server type
  command: 'npx', // Command to execute
  args: ['-y', '@modelcontextprotocol/server-everything'], // Command arguments
})

Scenario 2: Open Files or Folders Precisely (`openFile` / `openFolder`)

In automation tools or documentation, you can guide users to open a project in Cursor or jump directly to a specific code line:

import { openFile } from 'protocol-launcher/cursor'

const url = openFile({
  path: '/Users/dev/project/src/main.ts', // File path to open
  line: 10, // Optional: Jump to line 10
  column: 5, // Optional: Jump to column 5
  openInNewWindow: true, // Optional: Open in new window
})

Scenario 3: Start AI Chat with a Preset Prompt (`createChat`)

This is a particularly powerful feature unique to Cursor. You can send users straight into a conversation with pre-defined context or questions:

import { createChat } from 'protocol-launcher/cursor'

const url = createChat({
  prompt: 'Please help me refactor this code to improve readability and performance.', // Preset prompt
})

Why Protocol Launcher?

Automatic encoding and CJK support: Cursor’s protocol parameters can be tricky to handle. The library takes care of all escaping logic so that Chinese descriptions and prompts are never garbled when the app is launched.
Type safety: While writing MCP configurations, your IDE will remind you that stdio requires command and sse requires url, significantly reducing configuration failures.
Extreme tree shaking: A modular design enables tree shaking to minimize bundle size:
- Recommended: Use subpath imports such as import { installMCP } from 'protocol-launcher/cursor'.
- Full import: You can also import from the root package (for example, import { cursor } from 'protocol-launcher').
Simplified complex parameters: For example, the library can handle special headers and URL encodings required by streamable_http and other protocols, letting you focus purely on business-level configuration.

Conclusion

With Protocol Launcher, you can deeply integrate Cursor’s AI collaboration capabilities into your documentation and toolchain. Whether you’re distributing MCP toolkits or guiding users through AI-assisted refactoring, it is a professional and convenient choice.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
Cursor Module Docs: Cursor | Protocol Launcher

Protocol Launcher Series: One-Click GitHub Desktop Collaboration

zhensherlock — Sat, 28 Feb 2026 13:48:23 +0000

After introducing one-click configuration for VS Code, today we’ll look at how Protocol Launcher integrates with GitHub Desktop to make Git collaboration smoother.

As a developer or documentation maintainer, you may often encounter scenarios like:

Providing an “Open in GitHub Desktop” button in the README so users can quickly clone a repo.
Clicking a link on an internal platform to jump directly to a specific branch in the local client.
Guiding users to quickly locate and view a particular file in GitHub Desktop.

With Protocol Launcher, you can stop manually concatenating complex x-github-client:// protocol links and instead improve collaboration efficiency in a type-safe way.

GitHub Desktop and Deep Links

GitHub Desktop provides powerful deep link support, allowing you to trigger operations like cloning, switching branches, or opening files directly from web pages or third-party applications.

However, manually constructing these links usually means dealing with tricky parameter encoding (for example, the url parameter often needs to be double-encoded) and working without any type hints — which makes it easy to get things wrong.

Core Capabilities: Automated Cloning and Precise Navigation

Protocol Launcher offers a dedicated protocol-launcher/github-desktop module for GitHub Desktop with the following core features:

One-click open/clone repository: Specify the owner, repository name, and a particular branch.
Open files precisely: Jump directly to a specific file path in the local client.
Automatic protocol handling: Internally handles GitHub-specific parameter encoding rules to ensure links are 100% valid.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the GitHub Desktop module on demand
import { openRepo, openFile } from 'protocol-launcher/github-desktop'

// You can also import from the root package, but this will include all app modules
// import { githubDesktop } from 'protocol-launcher'

Scenario 1: One-Click Open or Clone a Repository (`openRepo`)

This is the most common feature. You can guide users to clone a repository or open an existing one in GitHub Desktop:

import { openRepo } from 'protocol-launcher/github-desktop'

const url = openRepo({
  owner: 'zhensherlock', // GitHub Username or Organization Name
  repo: 'protocol-launcher', // Repository Name
  branch: 'main', // Optional: Branch Name
})

Scenario 2: Open a Local File Precisely (`openFile`)

If you want users to quickly inspect a specific file in the local client:

import { openFile } from 'protocol-launcher/github-desktop'

const url = openFile({
  owner: 'zhensherlock', // GitHub Username or Organization Name
  repo: 'protocol-launcher', // Repository Name
  branch: 'main', // Optional: Branch Name
  path: 'packages/shared/src/index.ts', // File Path Relative to Repository Root
})

Why Protocol Launcher?

Automatic encoding and Unicode support: GitHub Desktop’s protocol has strict requirements on parameter encoding. The library handles all escaping logic internally to ensure that generated URLs never become garbled when launching the app.
Type safety and parameter hints: TypeScript IntelliSense ensures you provide the required owner and repo parameters and reminds you about optional branch names and paths.
Consistent user experience: By encapsulating complex protocol logic, you can focus on business features instead of worrying about subtle cross-OS differences in how protocols are triggered.
Extreme tree shaking: The modular design supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports (for example, import { openRepo } from 'protocol-launcher/github-desktop') so the bundler only includes the relevant code.
- Full import: You can also import from the root package (for example, import { githubDesktop } from 'protocol-launcher'), but for production builds, subpath imports are recommended.

Conclusion

With Protocol Launcher, you can dramatically lower the barrier for users to participate in Git-based collaboration. Whether in open-source project documentation or internal enterprise code management platforms, it is the most elegant bridge between the web and the local Git client.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
VS Code Module Docs: VS Code | Protocol Launcher

Protocol Launcher Series: Gracefully Launch VS Code from Web Pages and CLI

zhensherlock — Fri, 27 Feb 2026 10:07:53 +0000

After introducing one-click configuration for Cherry Studio, let’s look at the editor developers use most often — Visual Studio Code (VS Code).

As developers, we frequently need flows like:

Click a file path on an error log page to open that file in local VS Code and jump directly to the error line.
Automatically open the generated project directory in VS Code after a CLI tool finishes its work.
Guide users to connect to a remote server and open a specific development directory with one click.
Provide a button in documentation that opens a related configuration file directly in the editor.

VS Code Protocols and Deep Links

Visual Studio Code offers powerful deep link support, allowing developers to trigger editor actions directly from external apps, web pages, or the command line via the vscode:// protocol.

However, manually assembling these links often involves complex path handling, line and column calculations, and tedious character encoding.

With Protocol Launcher, you can wrap all of this into simple function calls and get elegant app launch behavior.

Core Capabilities: Precise Control and Remote Support

Protocol Launcher provides a dedicated protocol-launcher/vscode module with the following core features:

Open files precisely: Jump to an exact line and column.
Manage workspaces: Open local folders or project directories with one call.
Remote development integration: Trigger remote connections via SSH or other protocols.
Quick system actions: For example, jump to the settings UI in one click.

Quick Start

First, make sure you have installed the package:

npm install protocol-launcher

In your code, you can choose between two import styles:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the VS Code module on demand
import { openFile, openFolder, openRemote, openSettings, installMCP } from 'protocol-launcher/vscode'

// You can also import from the root package, but this will include all app modules
// import { vscode } from 'protocol-launcher'

Scenario 1: Install an STDIO MCP Service (`installMCP`)

The following example installs the official server-everything test server, which is ideal for validating VS Code’s MCP capabilities:

import { installMCP } from 'protocol-launcher/vscode'

const url = installMCP({
  name: 'server-everything', // Service name, for display and identification
  type: 'stdio', // Communication type, supports stdio, streamable_http, sse, etc.
  command: 'npx', // Startup command, e.g., npx, docker, etc.
  args: ['-y', '@modelcontextprotocol/server-everything'], // Startup arguments
})

You can bind the generated url to a button or link so users can add an MCP service in VS Code with a single click.

Scenario 2: Install a Streamable HTTP MCP Service (`installMCP`)

For cloud-hosted MCP services, you can use the streamable_http transport protocol and configure authentication via url and headers:

import { installMCP } from 'protocol-launcher/vscode'

const url = installMCP({
  name: 'QCC Company Info MCP', // Service name, for display and identification
  type: 'streamable_http', // Communication type, supports stdio, streamable_http, sse, etc.
  url: 'https://mcp.qcc.com/basic/stream', // Service URL
  headers: { // Custom headers, for authentication, etc.
    Authorization: 'YOUR_QCC_TOKEN',
  },
})

Scenario 3: Install an SSE MCP Service (`installMCP`)

If your service pushes results to VS Code via Server-Sent Events (SSE), you can install it using type: 'sse':

import { installMCP } from 'protocol-launcher/vscode'

const url = installMCP({
  name: 'QCC Company Risk MCP', // Service name, for display and identification
  type: 'sse', // Communication type, supports stdio, streamable_http, sse, etc.
  url: 'https://mcp.qcc.com/basic/sse', // Service URL
  headers: { // Custom headers, for authentication, etc.
    Authorization: 'YOUR_QCC_TOKEN',
  },
})

Scenario 4: Open a File Precisely (`openFile`)

You can specify the file path, line, and column, and even decide whether to open it in a new window. This is especially useful for error monitoring systems or log analysis tools:

import { openFile } from 'protocol-launcher/vscode'

const url = openFile({
  path: '/Users/dev/project/src/index.ts', // Absolute path to the file
  line: 42, // Optional: jump to line 42
  column: 10, // Optional: jump to column 10
  openInNewWindow: true, // Optional: whether to open in a new window
})

Scenario 5: Open a Folder or Workspace (`openFolder`)

After a scaffolding tool or automation script finishes running, you can automatically open the project directory for the user:

import { openFolder } from 'protocol-launcher/vscode'

const url = openFolder({
  path: '/Users/dev/project', // Absolute path to the folder
  openInNewWindow: false, // Optional: whether to open in a new window
})

Scenario 6: Remote Development Connection (`openRemote`)

If you want to guide users to develop on a remote server, you can generate an SSH remote development link directly. This greatly simplifies configuring remote environments:

import { openRemote } from 'protocol-launcher/vscode'

const url = openRemote({
  type: 'ssh-remote', // Remote type, supports ssh-remote, wsl, dev-container
  host: 'root@172.18.105.209:22', // Remote host identifier, e.g., root@IP or SSH Alias
  path: '/code/my-project', // Path inside the remote environment
})

Scenario 7: One-Click Settings (`openSettings`)

If you’re building a VS Code extension or related tool, you can use this link to guide users to the settings interface:

import { openSettings } from 'protocol-launcher/vscode'

const url = openSettings()

Why Protocol Launcher?

Automatic encoding and Unicode support: Whether it’s Chinese paths, special symbols, or complex CJK characters, the library handles them internally to ensure generated URLs are valid and never garbled when launching the app. You no longer need to manually call encodeURIComponent.
Type safety and parameter hints: TypeScript IntelliSense shows which parameters are optional and which are required (for example, line must be a number). This is especially important when composing complex remote connection links.
Cross-platform compatibility: Generated links follow VS Code’s official specifications and behave consistently across macOS, Windows, and Linux, hiding low-level protocol differences.
Extreme tree shaking: The modular design supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports (such as import { openFile } from 'protocol-launcher/vscode') so that the bundler only includes VS Code–related code instead of logic for all other apps.
- Full import: For simple scripts or demos, you can import from the root package (such as import { vscode } from 'protocol-launcher'), but this will include all supported application modules. For production, subpath imports are recommended.

Conclusion

VS Code’s deep link support is already very powerful, and Protocol Launcher makes it even easier and more robust to use. Whether in web pages or command-line tools, it is a great way to launch the editor.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
VS Code Module Docs: VS Code | Protocol Launcher

Protocol Launcher Series: One-Click Setup of Cherry Studio MCP Services and AI Models

zhensherlock — Wed, 25 Feb 2026 07:09:31 +0000

In the previous article, we introduced how Protocol Launcher generates app-launch links in a type-safe way. Today, we’ll dive into the first stop of this series: Cherry Studio.

Cherry Studio Protocol

Cherry Studio is a powerful desktop AI client. It supports connecting to multiple AI model providers (such as OpenAI, Anthropic, DeepSeek, etc.) and has full support for the MCP (Model Context Protocol).

However, manually configuring an MCP server or AI provider in Cherry Studio often requires filling out a lot of form fields: name, description, command, arguments, environment variables, base URL… A small mistake can easily lead to configuration failures.

Now, with Protocol Launcher, you can wrap all these complex settings into a single URL link and achieve “one-click installation”.

Core Capabilities: `installMCP` and `installProvider`

Protocol Launcher provides a dedicated protocol-launcher/cherry-studio module for Cherry Studio with the following core features:

Automatic MCP server configuration: Supports multiple transport protocols such as stdio, sse, and streamableHttp.
Batch installation: Install multiple MCP servers in one go.
One-click import of AI providers: Quickly configure model API keys and proxy/base URLs.

Quick Start

First, make sure you have installed the package in your project:

npm install protocol-launcher

In your code, you can choose between two import styles depending on your needs:

On-demand imports (via subpaths) with tree shaking for smaller bundle size.
Full imports (from the root package) with simpler syntax but including all supported app logic.

// ✅ Recommended: load only the Cherry Studio module on demand
import { installMCP, installProvider } from 'protocol-launcher/cherry-studio'

// You can also import from the root package, but this will include all app modules
// import { cherryStudio } from 'protocol-launcher'

Scenario 1: Install an STDIO MCP Service

If you’ve developed a locally running MCP service (for example, one started via npx), you can use the following code to generate an installation link. By adding parameters such as logoUrl, description, and tags, users will see a professional, trustworthy branded card during installation:

import { installMCP } from 'protocol-launcher/cherry-studio'

const url = installMCP({
  name: 'server-everything',
  description:
    'This MCP server tries to exercise all features of the MCP protocol. It is not only a useful server, but also a powerful testing tool for MCP client builders.',
  type: 'stdio',
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-everything'],
  registryUrl: 'https://registry.npmmirror.com',
  provider: 'Anthropic',
  providerUrl: 'https://modelcontextprotocol.io/',
  logoUrl: 'https://avatars.githubusercontent.com/u/182288589?s=200&v=4',
})

Scenario 2: Batch Install Multiple MCP Services

For enterprise use cases, you may want to guide users to install a whole toolset at once. By enriching fields like tags and providerUrl, you can achieve better categorization, display, and quick navigation:

import { installMCP } from 'protocol-launcher/cherry-studio'

const url = installMCP({
  mcpServers: {
    'qcc-company-basic': {
      name: 'QCC Company Info MCP',
      description:
        'The Company Info MCP provides comprehensive enterprise profiling and insights, helping you quickly verify business authenticity, assess stability and development trajectory, and provide solid data support for your business decisions.',
      type: 'streamableHttp',
      baseUrl: 'https://mcp.qcc.com/basic/stream',
      headers: {
        Authorization: 'YOUR_TOKEN',
      },
      provider: 'QCC',
      providerUrl: 'https://openapi.qcc.com/mcpTools?service=basic',
      logoUrl: 'https://openapi.qcc.com/favicon.ico',
      tags: ['company-basic', 'enterprise-info'],
      timeout: 30,
    },
    'qcc-company-risk': {
      name: 'QCC Company Risk MCP',
      description:
        'The Company Risk MCP provides a comprehensive enterprise risk scan, identifying credit and compliance issues across legal, administrative, and operational dimensions. It helps you accurately evaluate the reliability of partners and avoid business pitfalls and associated risks.',
      type: 'sse',
      baseUrl: 'https://mcp.qcc.com/basic/sse',
      headers: {
        Authorization: 'YOUR_TOKEN',
      },
      provider: 'QCC',
      providerUrl: 'https://openapi.qcc.com/mcpTools?service=risk',
      logoUrl: 'https://openapi.qcc.com/favicon.ico',
      tags: ['company-risk', 'risk-info'],
      timeout: 30,
    },
  },
})

Scenario 3: Configure an AI Provider

Besides MCP, you can also guide users to configure model providers. For example, configuring DeepSeek:

import { installProvider } from 'protocol-launcher/cherry-studio'

const url = installProvider({
  id: 'deepseek',
  baseUrl: 'https://api.deepseek.com',
  apiKey: 'sk-xxxxxx',
})

Why Protocol Launcher?

Excellent visual presentation: By providing logoUrl, description, and tags, users in Cherry Studio no longer see plain code, but information-rich configuration cards with official branding and clear feature descriptions. This professional look greatly increases user trust and willingness to adopt.

Image: Cherry Studio MCP card after filling in all parameters — professional and trustworthy

Enhanced interactivity: Parameters such as providerUrl can render shortcut buttons in the app, allowing users to jump to the official website or documentation center with one click.
Type safety: While writing configurations, your IDE can automatically hint which fields are required (for example, stdio must have command, while sse must have baseUrl).
Automatic encoding and Unicode support: You no longer need to manually call encodeURIComponent; Protocol Launcher automatically handles all special characters. More importantly, it fully supports CJK characters. Whether you use Chinese descriptions, Japanese tags, or Korean provider names, you can be sure there will be no garbled text when launching the application.
Extreme tree shaking: Protocol Launcher adopts a modular design and supports tree shaking to minimize bundle size:
- Recommended: Use subpath imports (such as import { ... } from 'protocol-launcher/cherry-studio'). Build tools will only include the Cherry Studio–related code and will not pull in logic for other apps.
- Full import: For simple scripts or demos, you can also import from the root package (such as import { cherryStudio } from 'protocol-launcher'), but this includes all supported app modules. For production, it is recommended to use subpath imports.

Conclusion

With Protocol Launcher, developers can dramatically lower the barrier for users to adopt MCP services. Whether you’re adding an “Add to Cherry Studio” button in documentation or distributing configurations via automation scripts, it is the most elegant option.

🔗 Related Links

Protocol Launcher Website: https://protocol-launcher.vercel.app
Cherry Studio Module Docs: Cherry Studio | Protocol Launcher

Elegantly Generate Type-Safe App Launch Links with Protocol Launcher

zhensherlock — Tue, 24 Feb 2026 06:46:10 +0000

As developers, we often need to use URL schemes (deep links) to interact with local applications: opening VS Code from a web page and jumping to a specific line in one click, triggering a Git client to clone a repository via the CLI, or configuring IDEs inside automation scripts.

Before Protocol Launcher, this usually meant suffering through manually concatenated strings:

// ❌ Before: error-prone, hard to maintain, no type hints
const url = "vscode://file/" + filePath + ":" + line // and you still have to handle encodeURIComponent yourself

Now it’s time to solve this elegantly with Protocol Launcher.

What Is Protocol Launcher?

Protocol Launcher is a lightweight TypeScript library designed to generate safe, valid “quick launch” URLs for various applications. It standardizes how deep links are constructed and delivers an excellent developer experience.

Key Features

🛡️ Strong Type Safety

Built on TypeScript, Protocol Launcher provides strict parameter typings for every supported application. You no longer need to worry about misspelled parameters or invalid values. IDE IntelliSense guides you through configuration with code completion.

🌿 Aggressive Tree Shaking

Worried that pulling in an extra library will bloat your bundle? Protocol Launcher is modular and fully supports tree shaking. If you only need VS Code support, only the VS Code-related code gets bundled.

// ✅ Recommended: import only what you need for minimal bundle size
import { openFile } from 'protocol-launcher/vscode'

🔐 Security and Compatibility

Automatic encoding: Built-in safe encoding logic automatically handles special characters in URLs and mitigates injection risks.
Unicode support: Fully supports Chinese paths and filenames, so you never need to worry about garbled text again.
Zero runtime dependencies: The library has no external runtime dependencies, keeping your node_modules clean.

Broad Application Support

Protocol Launcher already supports the tools developers use most often, and the list is still growing:

Editors / IDEs: VS Code, Cursor, Xcode, IntelliJ IDEA, WebStorm, PyCharm, GoLand, PhpStorm, RustRover
AI tools: Cherry Studio
Collaboration & utilities: GitHub Desktop, Telegram, Thunder (Xunlei)

Getting Started

1. Install

Use your preferred package manager:

npm install protocol-launcher
# or
pnpm add protocol-launcher

2. Usage Examples

Suppose we want to open a file in VS Code:

import { openFile } from 'protocol-launcher/vscode'

const link = openFile({
  path: '/Users/dev/project/src/app.ts',
  line: 42,
  column: 10,
})

// The generated link is safe and well-formed, ready for window.open or terminal usage
console.log(link)

Or open a repository in GitHub Desktop:

import { openRepo } from 'protocol-launcher/github-desktop'

const link = openRepo({
  owner: 'zhensherlock',
  repo: 'protocol-launcher',
  branch: 'main',
})

Conclusion

Protocol Launcher takes the “generate app links” detail and pushes it to the extreme. It is simple, reliable, and efficient. If you are building web pages, CLI tools, or desktop apps that need to integrate with local applications, Protocol Launcher is an ideal choice.

🔗 Try it now: Documentation | GitHub

DEV Community: zhensherlock

Protocol Launcher Series: One-Click Telegram Chats and Channels

Telegram and Deep Links

Core Capabilities: One-Click Open and Precise Navigation

Quick Start

Scenario 1: Open the Telegram Client from the Web (open)

Scenario 2: Jump to a Specific Username or Channel (openDomain)

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: One-Click Launch for IntelliJ IDEA and JetBrains IDEs

IntelliJ IDEA and Deep Links

Core Capability: Unified Project Launch Across IDEs

Quick Start

Scenario 1: Precisely Open a File in IntelliJ IDEA (openFile)

Scenario 2: Open a Project or Module Root (openFolder)

Reusing the Same Logic Across Other JetBrains IDEs

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: One-Click CodeBuddy Development Experience

CodeBuddy and Deep Links

Core Capabilities: Fast and Versatile

Quick Start

Scenario 1: Open a File Precisely (openFile)

Scenario 2: One-Click Remote Environment Connection (openRemote)

Scenario 3: Open a Folder (openFolder)

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: Powering Cursor with MCP Services and AI

Cursor and the MCP Protocol

Core Capabilities: Automated Setup and Smart Interaction

Quick Start

Scenario 1: One-Click MCP Service Installation (installMCP)

Scenario 2: Open Files or Folders Precisely (openFile / openFolder)

Scenario 3: Start AI Chat with a Preset Prompt (createChat)

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: One-Click GitHub Desktop Collaboration

GitHub Desktop and Deep Links

Core Capabilities: Automated Cloning and Precise Navigation

Quick Start

Scenario 1: One-Click Open or Clone a Repository (openRepo)

Scenario 2: Open a Local File Precisely (openFile)

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: Gracefully Launch VS Code from Web Pages and CLI

VS Code Protocols and Deep Links

Core Capabilities: Precise Control and Remote Support

Quick Start

Scenario 1: Install an STDIO MCP Service (installMCP)

Scenario 2: Install a Streamable HTTP MCP Service (installMCP)

Scenario 3: Install an SSE MCP Service (installMCP)

Scenario 4: Open a File Precisely (openFile)

Scenario 5: Open a Folder or Workspace (openFolder)

Scenario 6: Remote Development Connection (openRemote)

Scenario 7: One-Click Settings (openSettings)

Why Protocol Launcher?

Conclusion

Protocol Launcher Series: One-Click Setup of Cherry Studio MCP Services and AI Models

Cherry Studio Protocol

Core Capabilities: installMCP and installProvider

Quick Start

Scenario 1: Install an STDIO MCP Service

Scenario 2: Batch Install Multiple MCP Services

Scenario 3: Configure an AI Provider

Why Protocol Launcher?

Conclusion

Elegantly Generate Type-Safe App Launch Links with Protocol Launcher

What Is Protocol Launcher?

Key Features

🛡️ Strong Type Safety

🌿 Aggressive Tree Shaking

🔐 Security and Compatibility

Broad Application Support

Getting Started

1. Install

2. Usage Examples

Conclusion

Scenario 1: Open the Telegram Client from the Web (`open`)

Scenario 2: Jump to a Specific Username or Channel (`openDomain`)

Scenario 1: Precisely Open a File in IntelliJ IDEA (`openFile`)

Scenario 2: Open a Project or Module Root (`openFolder`)

Scenario 1: Open a File Precisely (`openFile`)

Scenario 2: One-Click Remote Environment Connection (`openRemote`)

Scenario 3: Open a Folder (`openFolder`)

Scenario 1: One-Click MCP Service Installation (`installMCP`)

Scenario 2: Open Files or Folders Precisely (`openFile` / `openFolder`)

Scenario 3: Start AI Chat with a Preset Prompt (`createChat`)

Scenario 1: One-Click Open or Clone a Repository (`openRepo`)

Scenario 2: Open a Local File Precisely (`openFile`)

Scenario 1: Install an STDIO MCP Service (`installMCP`)

Scenario 2: Install a Streamable HTTP MCP Service (`installMCP`)

Scenario 3: Install an SSE MCP Service (`installMCP`)

Scenario 4: Open a File Precisely (`openFile`)

Scenario 5: Open a Folder or Workspace (`openFolder`)

Scenario 6: Remote Development Connection (`openRemote`)

Scenario 7: One-Click Settings (`openSettings`)

Core Capabilities: `installMCP` and `installProvider`