Does Palmier Pro Have a Command-Line Interface? Terminal Launch Guide

Palmier Pro does not ship a dedicated command-line tool with sub-commands, but you can launch the graphical macOS application directly from the terminal using its Swift executable target.

Palmier Pro is distributed as a Swift executable target in the palmier-io/palmier-pro repository. While the project produces a standard macOS GUI application, understanding its command-line interface capabilities helps developers integrate it into automated workflows or launch it from shell scripts.

How Palmier Pro Handles Command-Line Execution

The project structure reveals that Palmier Pro is built as a single binary rather than a traditional .app bundle, enabling direct terminal execution.

The Executable Target Configuration

In Package.swift, the repository declares an executable target named PalmierPro:

.executable(name: "PalmierPro", ...)

This configuration tells the Swift compiler to emit a single binary that can be invoked directly from the shell. When you run swift build, the compiler produces .build/release/PalmierPro, which functions as the command-line entry point.

Entry Point and Application Lifecycle

The execution flow begins in Sources/PalmierPro/App/main.swift, which instantiates NSApplication, assigns the delegate, and calls app.run(). This standard macOS UI entry point handles both traditional GUI launches and terminal-based invocations.

The Sources/PalmierPro/App/AppDelegate.swift file contains a critical comment confirming CLI support: "Activate the app (required when launched from CLI, not a .app bundle)". Inside applicationDidFinishLaunching, the code calls NSApp.setActivationPolicy(.regular) to ensure the UI appears even when the binary is launched from a shell environment.

Launching Palmier Pro From the Terminal

You can build and run Palmier Pro directly from the command line without generating a .app bundle. This requires Swift 6.2 and macOS 26.

Building the Executable

Compile the release binary using Swift Package Manager:

# Build the executable

swift build -c release

This produces .build/release/PalmierPro, which you can execute directly.

Running the Application

Launch the binary using either the built artifact or Swift's quick-run shortcut:

# Run the built binary directly

.build/release/PalmierPro

# Or use swift run for development builds

swift run PalmierPro

When executed, the binary initializes the full graphical editor. The AppDelegate automatically handles activation policies to ensure the menu bar and windows appear correctly, regardless of whether the process originated from Finder or a terminal session.

Command-Line Arguments and Sub-Commands

Palmier Pro does not expose a separate command-line interface with sub-commands (such as palmier-pro export or palmier-pro init). All functionality—including project creation, AI-driven generation, and editing—must be accessed through the GUI after launch.

The scripts/ directory (containing files like dev.sh and release.sh) provides helper utilities for building and packaging the application, but these are development tools rather than user-facing CLI commands. There is no argument parser or help flag implemented in the main executable; the binary expects to launch as a standard macOS application.

Summary

• Palmier Pro is configured as a Swift executable target in Package.swift, producing a binary named PalmierPro.
• You can launch the application from the terminal using swift run PalmierPro or by executing the built binary at .build/release/PalmierPro.
• The AppDelegate.swift explicitly handles CLI launches by setting the activation policy, ensuring the GUI appears when started from a shell.
• No dedicated command-line tool exists; the repository does not support sub-commands or headless operation, and all features require the graphical interface.

Frequently Asked Questions

Can I run Palmier Pro entirely from the command line without a GUI?

No. While you can launch the binary from the terminal, Palmier Pro always initializes the macOS graphical interface. The AppDelegate calls NSApp.setActivationPolicy(.regular) and presents the full editor window. There is no headless or CLI-only mode for performing operations like code generation or project management without the GUI.

How do I build the Palmier Pro executable for terminal use?

Run swift build -c release from the repository root. This generates .build/release/PalmierPro, which you can move to your PATH or invoke directly. The build requires Swift 6.2 and targets macOS 26. You can also use swift run PalmierPro for development and testing without creating a release build.

Are there any command-line arguments supported by the Palmier Pro binary?

The binary does not implement a command-line argument parser or support flags like --help or --version. The main.swift entry point immediately initializes the Cocoa application lifecycle without inspecting arguments. Any scripts requiring automation should interact with the GUI using macOS accessibility APIs rather than CLI arguments.

What is the difference between the executable and a .app bundle?

The raw executable (.build/release/PalmierPro) is a single binary that you run directly from the terminal. A .app bundle is a directory structure containing the same binary along with resources, Info.plist, and metadata required for Finder integration and Mac App Store distribution. Both launch the same GUI, but the executable requires explicit activation handling in AppDelegate.swift to ensure proper UI presentation when launched outside a bundle context.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}