Menuet

Since macOS menus dismiss immediately upon clicking an item, use the State field on a menuet.Regular item to show a checkmark for toggles. When the item is clicked, update your application state, and ensure the next time the menu is rendered, the State reflects the new value.

menuet.Regular{
    Text:    "Notifications enabled",
    State:   prefs.NotificationsEnabled,
    Clicked: func() { prefs.NotificationsEnabled = !prefs.NotificationsEnabled },
}

Menuet requires macOS. You can install the v2 package using go get:

go get github.com/caseymrm/menuet/v2

You can deploy the OAuth redirect trampoline to Cloudflare Pages using the Wrangler CLI. This service is intended to be deployed to the menuet-auth project on the main branch.

npx wrangler pages deploy web/auth --project-name menuet-auth --branch main

The auth.menuet.app service acts as a generic OAuth redirect trampoline for Menuet applications. It is designed to handle OAuth providers that require an https redirect URI, which is a common requirement for many modern identity providers.

How it works

When an OAuth provider redirects to https://auth.menuet.app/<app>, the service forwards the query string to your application's local loopback listener using a top-level https $\rightarrow$ http navigation. Browsers permit this specific transition for 127.0.0.1 addresses.

Registering a new application

To add a new application to the trampoline:

1. Add a new entry for your application in the apps map within the index.html file of the web/auth directory.
2. Register the URI https://auth.menuet.app/<app> (replacing <app> with your application's identifier) with your OAuth provider.

While go run works for development, certain features like Notifications, Start at Login, and Auto-update require the binary to be inside a proper macOS .app bundle.

To automate this, use the provided menuet.mk Makefile. Create a Makefile in your app directory with the following structure:

APP=My App
IDENTIFIER=com.example.myapp
include $(GOPATH)/src/github.com/caseymrm/menuet/menuet.mk

Commands

• make run: Builds the binary into My App.app/Contents/MacOS/myapp, generates the Info.plist using your CFBundleIdentifier, and launches it.
• make sign: Signs the bundle using a Developer ID Application certificate from your Keychain (set the IDENTITY variable to your certificate name).

In Menuet, all items within a menu must implement the MenuItem interface. The primary concrete types you will use are Regular for standard rows, Separator for dividers, Search for in-menu search fields, and Image for large picture rows. These items are typically returned by the Children callback of a Regular item or the root application.

type MenuItem interface {
	menuItem()
}

A Shortcut represents a global keyboard shortcut. When assigned to a Regular menu item, it performs two actions:

1. Displays the shortcut in the menu (e.g., ⌘N).
2. Fires the item's Clicked callback when the keys are pressed system-wide, even if the application is not in the foreground.

Note: Identical KeyCode and Modifiers combinations cannot be used for multiple menu items. The first item registered with a specific shortcut will receive the trigger; subsequent registrations of the same shortcut will be silently ignored. It is recommended to use distinct shortcuts for every action.

// Example of defining a shortcut
shortcut := menuet.Shortcut{
	KeyCode:   menuet.KeyN,
	Modifiers: menuet.ModCmd,
}

To create a macOS menu bar application, use the App() singleton to configure your application's properties and then call RunApplication().

Note that RunApplication() is a blocking call that enters the AppKit run loop. If the environment variable MENUET_SNAPSHOT_PATH is set, the application will instead write a JSON snapshot of the current MenuState and return immediately without starting the UI loop.

package main

import "auth.menuet/menuet"

func main() {
	app := menuet.App()
	app.Name = "My App"
	app.Label = "com.example.myapp"
	app.Children = func() []menuet.MenuItem {
		return []menuet.MenuItem{
			menuet.Regular{Label: "Hello"},
		}
	}

	app.RunApplication()
}

Menuet provides GracefulShutdownHandles() to help you manage long-running goroutines when the user terminates the application. It returns a *sync.WaitGroup and a context.Context.

1. Use the WaitGroup to track all background goroutines your app starts.
2. Use the Context to signal those goroutines to stop when the app is closing.
3. The underlying C layer will call shutdownWait() which triggers the context cancellation and waits for the WaitGroup to finish before the process exits.

app := menuet.App()
wg, ctx := app.GracefulShutdownHandles()

go func() {
	wg.Add(1)
	defer wg.Done()
	for {
		select {
		case <-ctx.Done():
			return
		// do work
		}
	}
}()

app.RunApplication()

If your application is intended for distribution via the Mac App Store, you should not use menuet.Search.

Implementation details for menuet.Search rely on the private selector setKeyOverride: on NSPopupMenuWindow to enable text cursor focus and non-modal editing within an NSMenu. While this provides a seamless search experience for direct-distribution apps (like whyawake, notafan, or traytter), it violates App Store policies regarding private API usage.