A Swift package for executing AppleScript from macOS applications, featuring a built-in MCP server that lets AI assistants control macOS apps through pre-built command shortcuts.
JCAppleScript provides three components:
- JCAppleScript (library) - Core AppleScript execution engine
- AppShortcuts (library) - Registry of pre-built AppleScript commands for popular macOS apps
- jcas-mcp (executable) - MCP (Model Context Protocol) server for AI-driven app automation
Add JCAppleScript to your Package.swift:
dependencies: [
.package(url: "https://github.com/johnnyclem/JCAppleScript.git", from: "2.0.0")
]Then add the targets you need:
.target(
name: "YourTarget",
dependencies: [
"JCAppleScript", // Core engine only
"AppShortcuts", // App command registry
]
)import JCAppleScript
let engine = AppleScriptEngine.shared
// Execute raw AppleScript
let result = try engine.execute("""
tell application "Finder"
display dialog "Hello from Swift!"
end tell
""")
// Send a command to an application
let output = try engine.tell(application: "Music", command: "play")
// Execute a script file with variable substitution
let fileResult = try engine.executeFile(at: "/path/to/script.scpt", variables: ["Alice", "Hello!"])
// Execute JavaScript for Automation (JXA)
let jxa = try engine.execute("Application('Music').play()", language: .javaScript)
// Check syntax without executing
try engine.checkSyntax("tell application \"Finder\" to activate")
// All execution APIs also have async variants
let asyncResult = try await engine.execute("return 40 + 2")When embedding untrusted values in script source, escape them first:
let userInput = "…"
let script = "display dialog \(AppleScriptString.quoted(userInput))"import AppShortcuts
let registry = AppRegistry.shared
// Execute a pre-built command
let result = try registry.executeCommand("messages.send_message", arguments: [
"recipient": "+15551234567",
"message": "Hello from JCAppleScript!"
])
// Discover available commands
let commands = registry.commands(forApp: "Reminders")
for cmd in commands {
print("\(cmd.id): \(cmd.name) - \(cmd.description)")
}
// Search across all apps
let results = registry.searchCommands("send")The jcas-mcp executable is a Model Context Protocol server that AI assistants (Claude, GPT, etc.) can use to control macOS applications.
It is published to the official MCP registry as io.github.johnnyclem/jcas-mcp, and each GitHub release ships a prebuilt jcas-mcp.mcpb bundle (universal macOS binary) that can be installed directly in Claude Desktop via Settings → Extensions.
Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"applescript": {
"command": "/path/to/jcas-mcp"
}
}
}Build the server:
swift build -c release
# Binary at: .build/release/jcas-mcp| Tool | Description |
|---|---|
execute_applescript |
Execute arbitrary AppleScript code † |
execute_jxa |
Execute JavaScript for Automation (JXA) code † |
tell_application |
Send a command to a specific app via tell block † |
check_script_syntax |
Compile a script (AppleScript or JXA) without executing it |
list_running_applications |
Get currently running applications |
list_registered_apps |
Browse all registered app command sheets |
search_commands |
Search for commands by keyword |
run_app_command |
Execute a pre-built command by ID |
preview_app_command |
Dry-run: show the exact script a command would execute |
get_app_commands |
Get detailed command info for a specific app |
† Hidden and disabled when the server runs in safe mode (see below).
| Environment variable | Effect |
|---|---|
JCAS_SAFE_MODE=1 |
Disables the arbitrary-code tools (execute_applescript, execute_jxa, tell_application) and registry commands flagged dangerous (e.g. terminal.run_command, safari.run_javascript). Only pre-built, sanitized registry commands remain available. |
JCAS_APP_MANIFESTS=a.json:b.json |
Colon-separated JSON manifest files with additional community app definitions to load at startup. |
CLI flags: jcas-mcp --manifest prints the full registry as JSON, --version prints the server version, --help shows usage.
User: "Send a message to John saying I'll be late"
AI uses tool: run_app_command
command_id: "messages.send_message"
arguments: { "recipient": "John", "message": "I'll be late" }
JCAppleScript ships with command sheets for 12 built-in macOS apps:
| App | Category | Commands | Examples |
|---|---|---|---|
| Messages | Communication | 6 | Send message, list chats, get participants |
| Communication | 7 | Compose email, search, check mail, list accounts | |
| Reminders | Productivity | 7 | Create/complete/delete reminders, search, list |
| Calendar | Productivity | 6 | Create events, list today's events, upcoming |
| Notes | Productivity | 8 | Create/search/append notes, manage folders |
| Finder | System | 12 | File operations, folder contents, labels, trash |
| Safari | Internet | 10 | Open URLs, manage tabs, run JavaScript, get page content |
| Music | Media | 13 | Playback control, playlists, library search, ratings |
| Terminal | Development | 8 | Run commands, manage windows/tabs, profiles |
| System Settings | System | 13 | Dark mode, volume, notifications, dialogs, system info |
| Xcode | Development | 20+ | Open/build/run/test projects, schemes, build logs, debugging |
| Speech Recognition | System | 3 | Listen for spoken phrases via the system speech engine |
Implement the ScriptableApp protocol to add support for any scriptable macOS app:
import AppShortcuts
struct MyApp: ScriptableApp {
static let bundleIdentifier = "com.example.myapp"
static let appName = "MyApp"
static let description = "My custom application"
static let category = AppCategory.productivity
static let commands: [AppCommand] = [
AppCommand(
id: "myapp.do_thing",
name: "Do Thing",
description: "Performs the thing",
parameters: [
CommandParameter(name: "input", description: "The input value"),
]
) { args in
let input = args["input", default: ""]
return """
tell application "MyApp"
do thing with "\(input)"
end tell
"""
},
]
}
// Register at runtime
AppRegistry.shared.register(MyApp.self)JCAppleScript is designed to grow through community contributions. The app shortcut system uses a standard protocol (ScriptableApp) that makes it easy to:
- Add new applications - Implement
ScriptableAppfor any scriptable macOS app - Extend existing apps - Submit new commands for already-registered apps
- Share command sheets - Export/import app definitions via JSON manifests
We're building a browsable registry (similar to npmjs.org) where you can:
- Browse applications and their supported AppleScript commands
- Submit new commands for existing apps
- Add entirely new applications to the registry
- Generate JSON manifests for integration with other tools
// Export all registered apps as manifest JSON
let json = try AppRegistry.shared.exportManifestJSON()
// Import community app definitions from a JSON manifest.
// Manifest commands are declarative script templates with ${param}
// placeholders; argument values are sanitized before substitution.
try AppRegistry.shared.loadManifest(contentsOf: URL(fileURLWithPath: "community.json"))Example manifest:
[
{
"name": "CoolApp",
"bundleIdentifier": "com.example.coolapp",
"description": "A community-contributed app",
"category": "Productivity",
"commands": [
{
"id": "coolapp.greet",
"name": "Greet",
"description": "Show a greeting",
"script": "tell application \"CoolApp\"\n greet \"${who}\"\nend tell",
"parameters": [
{"name": "who", "description": "Who to greet", "required": true, "type": "string"}
]
}
]
}
]The MCP server loads extra manifests from the JCAS_APP_MANIFESTS environment variable at startup.
Registry command arguments are sanitized before script generation:
- String, file-path, and date arguments are escaped (
\,", and control characters) so they cannot break out of AppleScript string literals. - Integer and boolean arguments are strictly validated/normalized — malformed values are rejected at validation and fall back to declared defaults during generation.
- Values outside a parameter's
allowedValueslist are dropped. - Arguments that don't correspond to a declared parameter are discarded.
Commands that execute caller-supplied code (Terminal shell commands, Safari JavaScript) are flagged dangerous and can be disabled wholesale with JCAS_SAFE_MODE=1. Use the preview_app_command tool to inspect the exact script a command will run before executing it.
Note that execute_applescript, execute_jxa, and tell_application execute arbitrary code by design — only expose them to clients you trust, or run the server in safe mode.
JCAppleScript/
├── Sources/
│ ├── JCAppleScript/ # Core engine
│ │ ├── AppleScriptEngine.swift
│ │ ├── AppleScriptSanitizer.swift
│ │ ├── ScriptResult.swift
│ │ └── ScriptError.swift
│ ├── AppShortcuts/ # App command registry
│ │ ├── AppProtocol.swift # ScriptableApp protocol
│ │ ├── AppCommand.swift # Command & parameter types + sanitization
│ │ ├── AppDefinition.swift # Instance-based app description
│ │ ├── AppManifest.swift # JSON import/export
│ │ ├── AppRegistry.swift # Central registry
│ │ └── Apps/ # Built-in app sheets
│ │ ├── MessagesApp.swift
│ │ ├── RemindersApp.swift
│ │ ├── FinderApp.swift
│ │ ├── SafariApp.swift
│ │ ├── MailApp.swift
│ │ ├── CalendarApp.swift
│ │ ├── NotesApp.swift
│ │ ├── MusicApp.swift
│ │ ├── TerminalApp.swift
│ │ └── SystemSettingsApp.swift
│ └── JCAppleScriptMCP/ # MCP server
│ ├── main.swift
│ ├── MCPServer.swift
│ ├── MCPTransport.swift
│ └── MCPTypes.swift
├── Tests/
├── Legacy/ # Original Obj-C implementation
├── Package.swift
└── LICENSE
- macOS 13.0+
- Swift 5.9+
The original Objective-C implementation (2013) is preserved in the Legacy/ directory for reference. It provided basic NSAppleScript wrapping with variable substitution. The new Swift implementation builds on those concepts while adding the MCP server, app registry, and modern Swift patterns.
MIT License - Copyright (c) 2013 John Clem. See LICENSE for details.