Skip to content

Instantly share code, notes, and snippets.

@0xdevalias

0xdevalias/integrating-workflow-automation-tools-apple-shortcuts-alfred-bettertouchtool-etc-via-cli-etc.md

Last active September 18, 2025 06:04
Show Gist options
  • Save 0xdevalias/8c76b00670ab00f2a0023bafb0867efe to your computer and use it in GitHub Desktop.
Save 0xdevalias/8c76b00670ab00f2a0023bafb0867efe to your computer and use it in GitHub Desktop.
Download ZIP
Some notes on integrating workflow automation tools such as Apple Shortcuts / Alfred / BetterTouchTool / etc via CLI and other methods.
Raw
integrating-workflow-automation-tools-apple-shortcuts-alfred-bettertouchtool-etc-via-cli-etc.md

Integrating Workflow Automation Tools (Apple Shortcuts, Alfred, BetterTouchTool, etc) via CLI, etc

Some notes on integrating workflow automation tools such as Apple Shortcuts / Alfred / BetterTouchTool / etc via CLI and other methods.

Table of Contents

TODO

A vague TODO list/plan of how I might flesh out this gist:

  • Decide on a canonical set of sub-headings to use for the various 'Workflow Automation Tools' sections (eg. Alfred, etc). At a minimum I think we should include focussed sections for things like: CLI, Apple Shortcuts widgets, AppleScript, URL Schema / x-callback-url, API (eg. http/json API server, etc), MCP(?), etc; and then maybe also a canonical sub-heading for relevant underlying paths/files like SQLite DBs, etc
  • Refactor the x-callback-url section to split the main URL Schema parts from the x-callback-url part (which should probably be a subheading of it)
  • Apple Shortcuts
    • Document usage of the shortcuts CLI
    • Add simple example of triggering a shortcut via CLI
    • Explore integration with widgets/automation
    • Note interoperability with Alfred or BTT
  • Alfred
    • Document how to call workflows via CLI
    • Add examples for external triggers
    • Explore inbound configuration
    • Add notes on call external trigger output handling
    • Summarize forum discussions:
      • Running workflows from CLI
      • Calling external triggers via alfred://runtrigger URI schemes
  • BetterTouchTool
    • Confirm whether BetterTouchTool has a native CLI
    • Document AppleScript integration
    • Add notes/examples for URL scheme triggering
    • Explore Apple Shortcuts widget integrations
    • Gather relevant references
  • Other Tools (Unsorted)
    • Brainstorm potential additions (e.g., Raycast, Hammerspoon, Keyboard Maestro)
      • Raycast is definitely probably worth adding given its popularity/etc these days
    • Decide if they belong in scope here or in separate gists
  • General / Unsorted
    • Add strengths/weaknesses of each tool; or at least some vibe of 'when I would choose one over the other' (or at least my personal usages currently; maybe as it's own sub-heading outside of the individual tools)
    • Capture gotchas/limitations for CLI triggering
    • Add sample code snippets (bash, AppleScript, etc.)
    • Add useful links (docs, forums, blog posts)
    • Crosslink back from each related 'see also' gist so they point to this new gist
  • Review this ChatGPT chat (private) and add any relevant resources from it to this gist if they aren't already here
    • Transcript Snippets

      Me:

      Are there any tools that let us easily identify the x-callback-urls or CFBundleURLSchemes for macOS / iOS apps in an automatic way?

      Ideally official Apple tools, CLI if possible; though if not, then I am also open to any open source tools, or blogs that describe the process, etc.

      Ideally I would like to be able to get a directory / listing of everything supported on a macOS / iOS device.

      ChatGPT:

      Here’s a summary of what I found on tools & methods (official / open source / hacky) to list out CFBundleURLSchemes / x-callback-URL support for iOS/macOS apps, plus gaps / limitations. If you want, I can try to dig up some scripts that more fully automate a per-device listing.

      What we already know: how URL schemes are declared

      • On iOS/macOS, apps that support custom URL schemes list them in their Info.plist under the key CFBundleURLTypes → CFBundleURLSchemes. (Apple Developer)
      • The x-callback-url spec is a convention built on top of URL schemes, allowing callbacks etc. Not all apps that have URL schemes support x-callback-URL; supporting that is up to the developer. (x-callback-url)

      Tools & methods

      Here’s what is available for extracting / listing schemes, both formally and via reverse engineering:

      Tool / Method What it does Platform (macOS / iOS) Pros / Limitations
      Manual from .ipa / .app file Unzip the .ipa (or inspect the .app bundle), find its Info.plist, parse out CFBundleURLSchemes. iOS (via .ipa) or macOS (if local .app) Works, but per-app; requires access to the binary / bundle. Not automatic across all installed apps. (Eric's Blog)
      Apple Configurator 2 + IPA extraction Use Apple Configurator to get a copy of an installed app (IPA), then inspect it. (Eric's Blog) macOS + connected iOS device Semi-manual; involves device connectivity; not a CLI for bulk listing.
      StackOverflow / blog & “How to find URL scheme” guides Various write-ups guide through reverse engineering / Info.plist inspection. (Dario MB) – Helpful tutorials. Good for one-off work.
      lsregister + LaunchServices dump on macOS On macOS, lsregister (part of LaunchServices) can dump info about applications and their handlers, including URL schemes. The LaunchServices database knows which apps “handle” various URL schemes. (book.hacktricks.wiki) macOS only Can get a listing of schemes + which app is the handler. Might not include all “deep link / callback” actions, only scheme registration. Permissions / sandboxing issues may limit what you see for apps not locally installed (or with special protections).
      utiluti A command-line tool for macOS that works with default apps, including URL schemes / file type handlers. (GitHub) macOS Good for default handlers; doesn’t necessarily list all schemes across all installed apps, especially ones that aren't default handlers.
      Blog / script “Determining URL scheme handlers in macOS” (brunerd) Has examples for listing all schemes a user has registered via parsing ~/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist for LSHandlerURLScheme. (brunerd.com) macOS Good for user’s registered scheme handlers. But not guaranteed to reveal every app’s scheme even if installed (only those that “claim” responsibility or are in the handlers database).
      xcall CLI tool Lets you invoke x-callback-urls from the command line. It doesn't scan for all schemes; it’s for sending / executing URL-callback requests. (GitHub) macOS Useful for testing / triggering, not for discovery.

      Gaps / Challenges

      • There is no known official Apple CLI that enumerates all URL schemes / x-callback endpoints for all installed apps on iOS devices (especially non-jailbroken ones). Apple’s APIs are restrictive for privacy/security.
      • Even for macOS, sandboxed apps or ones with special entitlements might not be exposed fully via LaunchServices or other public APIs.
      • For iOS, unless you have the IPA or source, many apps don’t publicly document all their URL schemes or x-callback-url actions.
      • “x-callback-url” is a convention; support for the callback parameters (x-success etc) isn’t guaranteed just by defining a scheme.

      Suggestions for more automatic listing

      If you want a more automatic / scripting approach, here are some ideas:

      1. On macOS: Use lsregister -dump + grep / parse for URL scheme entries. That can give you a list of schemes and which app handles them. Combine with mdls or plutil to inspect Info.plist of installed .app bundles (in /Applications, ~/Applications) to get all declared schemes.

      2. On iOS (device-attached): If you can extract the IPA (via Configurator or other device management tools), then script unzipping all IPAs and parsing their Info.plist files.

      3. Mobile device management (MDM) or enterprise tools: These might allow querying installed apps with more metadata (including URL schemes), depending on permissions.

      4. Reverse engineering / static analysis tools: Tools like classdump, strings, etc. Or using tools like frida to sniff or probe URL handling, though that gets more ad hoc.

      If you like, I can try to put together a small open-source script (bash / Swift / Python) that, when run on a macOS machine, lists all installed apps + their URL schemes / CFBundleURLTypes, and another tool that works with a connected iOS device (if possible). Do you want me to pull that together?

      Me:

      Sure. But if it doesn't need to be a full script and it can just be a few one liners, that would be ideal; but if it needs to be a script, then do it as a zsh script unless there is a strong reason why we should use something else

      ChatGPT:

      Nice — below are compact, practical one-liners (plus a small zsh script you can drop in if you want a cleaner output) for macOS and iOS workflows that enumerate CFBundleURLSchemes (and therefore the candidates for x-callback-style URLs). I prioritized CLI solutions and included the device-side options (Apple Configurator + libimobiledevice) with references so you can follow up. I also note limitations and caveats at the end.

      Short summary (sources)

      • CFBundleURLSchemes is where apps declare URL schemes in their Info.plist. (Apple Developer)
      • On macOS you can query LaunchServices (the LSHandlers plist or lsregister) or scan app bundles’ Info.plist. Good writeups + examples: brunerd / HackTricks. (Brunerd)
      • On iOS the usual approaches are: extract the .ipa (Apple Configurator can expose temporary IPAs), or use libimobiledevice tools / an iTunes backup to get the app bundle/Info.plist. (farkashtech.com)

      macOS — quick one-liners

      1. List schemes the user/LaunchServices knows about (fast, user-wide):
      plutil -convert json -o - ~/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist \
  | jq -r '.LSHandlers[]?.LSHandlerURLScheme' \
  | sort -u
      • What it does: converts the LaunchServices preferences to JSON and extracts all LSHandlerURLScheme entries (these are schemes the system knows handlers for). Good for a quick inventory of registered schemes. (Brunerd)
      1. Dump LaunchServices DB directly (another angle):
      /System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -dump \
  | sed -n '/URL scheme/,$p' | grep -E 'URL scheme|path:|bundle id' -B1 -A1
      • lsregister -dump shows what LaunchServices has indexed (useful for debugging/extra info). See HackTricks / LaunchServices docs. (HackTricks)
      1. Scan all local .app bundles for declared CFBundleURLSchemes (per-app authoritative source):
      for app in /Applications/*.app ~/Applications/*.app; do
  plist="$app/Contents/Info.plist"
  [ -f "$plist" ] || continue
  plutil -convert json -o - "$plist" \
    | jq -r '.CFBundleURLTypes[]?.CFBundleURLSchemes[]? as $s | "\(.CFBundleName // \"$(basename \"$app\")\")\t\($s)"' \
    2>/dev/null
done | sort -u
      • What it does: reads each app Info.plist, prints the app name + scheme. This is the most accurate declared list for apps installed as .app bundles on the Mac.

      macOS — small zsh script (clean CSV output)

      Save as list_mac_url_schemes.zsh and run:

      #!/usr/bin/env zsh
# list_mac_url_schemes.zsh - list app -> CFBundleURLSchemes as CSV
typeset -a dirs=(/Applications "$HOME/Applications" /Applications/Utilities)
echo "app_path,bundle_id,app_name,scheme"
for d in $dirs; do
  for app in "$d"/*.app(N); do
    plist="$app/Contents/Info.plist"
    [ -f "$plist" ] || continue
    json=$(plutil -convert json -o - -- "$plist" 2>/dev/null) || continue
    bundle=$(echo "$json" | jq -r '.CFBundleIdentifier // empty')
    name=$(echo "$json" | jq -r '.CFBundleName // .CFBundleDisplayName // empty')
    echo "$json" | jq -r --arg app "$app" --arg bundle "$bundle" --arg name "$name" \
      '.CFBundleURLTypes[]?.CFBundleURLSchemes[]? | [$app,$bundle,$name,.] | @csv' 2>/dev/null
  done
done
      • Requires jq. Output is CSV: app_path,bundle_id,app_name,scheme.

      iOS — practical (non-jailbroken) approaches

      Important: iOS doesn’t expose a system-wide CLI equivalent to LaunchServices for third-party apps on non-jailbroken devices. The reliable ways require either extracting the app bundle (.ipa) or using backup/MDM mechanisms. Two practical options:

      A — Use Apple Configurator to capture the .ipa and inspect

      1. Use Apple Configurator 2: add/download the app while device connected; the temporary .ipa appears under the Apple Configurator cache (you can watch that folder). See a walkthrough + a small monitor script. (farkashtech.com)

      2. Once you have app.ipa, extract the Info.plist and read schemes:

      unzip -p app.ipa 'Payload/*.app/Info.plist' > /tmp/Info.plist
plutil -convert json -o - /tmp/Info.plist | jq -r '.CFBundleURLTypes[]?.CFBundleURLSchemes[]?'
      • That yields the declared schemes for that app’s bundle.

      B — Use libimobiledevice family tools (enumerate apps / backups)

      • libimobiledevice (and ideviceinstaller / idevicebackup2) can enumerate installed apps and help create backups that contain app metadata you can inspect. It’s FOSS and widely used for tooling around iOS devices (non-jailbroken). Example flow: list apps, then back up / extract app container or Info.plist via backup tools, then parse CFBundleURLTypes. (libimobiledevice)

      Example commands (install libimobiledevice via Homebrew / package manager):

      # list installed apps (bundle ids)
ideviceinstaller -l

# (advanced) make a backup and extract Info.plist from the backup image of the app
# (exact steps depend on the version of libimobiledevice and iOS; see libimobiledevice docs)

      (Practical note: ideviceinstaller/ifuse/idevicebackup2 have different capabilities on different OS/iOS versions — check the docs.) (libimobiledevice)

      Limitations & caveats (short)

      • x-callback-url ≠ URL scheme: the x-callback spec is a convention (callbacks & parameters). Finding a scheme doesn’t guarantee the app supports x-callback parameters like x-success. You must test or find app docs/SDK to confirm. (Apple Developer)
      • iOS (non-jailbroken): you generally can’t enumerate every installed app’s internals remotely without extracting the IPA or using backup/MDM-level access — Apple intentionally restricts this for security/privacy. Apple Configurator or an MDM provide the practical workaround for non-jailbroken devices. (farkashtech.com)
      • LaunchServices / LSHandlers: on macOS the LaunchServices DB shows handlers the system knows about, but it may not list every possible scheme that an app declared internally (scanning the app bundle itself is the authoritative source for declared schemes). (Brunerd)

      Want me to do one of the following next?

      • Convert the macOS script into a single executable zsh file that outputs a neat CSV/JSON and includes optional sudo scanning of system app locations.
      • Produce a small Apple Configurator watcher script (based on the monitor example) that auto-copies IPAs for you and then runs the extraction pipeline. (I can drop that in zsh form.)
      • Build a tiny CLI scan-schemes zsh tool that tries LaunchServices → local app Info.plist → optionally extracts IPAs from a given folder and prints consolidated results.

      Tell me which of the three and I’ll produce it as a ready-to-run zsh script. (If you want the full CSV zsh script now, tell me and I’ll paste it — it’s quick.)

Workflow Automation Tools

This section covers workflow automation tools such as Apple Shortcuts, Alfred, BetterTouchTool, etc; and how they can be integrated and triggered.

See Also:

Apple Shortcuts

See Also:

TODO:

  • https://support.apple.com/en-au/guide/shortcuts-mac/apd455c82f02/mac

    • Run shortcuts from the command line

    • You can use the Terminal app on your Mac to run a shortcut from the command line. Running shortcuts from the command line is no different from running shortcuts in the Shortcuts app — you can pass documents, images, text and more. Then the shortcut can pass the output to another process or write to a file.

    • Although you can run nearly any shortcut from the command line, the most efficient shortcuts are ones that don’t show alerts or ask for input. When a shortcut asks for input, the command line process pauses, awaiting user input. Instead of using a Select action, configure your shortcut to receive specific content as input, and if no input is received ask the for the content.

    • Running shortcuts from the command line

      • Shortcuts are run using the shortcuts command.

        • eg. shortcuts run "The Shortcut Name"

      • You can pass images to shortcut using the -i or --input-path flag.

        • eg. shortcuts run "The Shortcut Name" -i ~/Desktop/*.jpg

      • If your shortcut ends with an action that produces text, images or some other file, or if you use the Stop and Output action, you can add the -o or --output-path flag to intelligently write the output to a file. For example, you could output text to a PDF or TXT file by providing a path with the proper file extension.

        To run the “Combine Images” shortcut combining all the images on the Desktop to a PNG file, you could use the following:

        shortcuts run "Combine Images" -i ~/Desktop/*.jpg -o ~/Desktop/combined.png

      • If the shortcut has an action that ends with output or has a Stop and Output action, you can pipe the output of a shortcut to another command using the | character. You can define the type of output (for example, forcing the output to be a JPEG instead of text) by using the --output-type flag with a Uniform Type Indicator.

        To run the “Combine Images” shortcut combining all the images on the Desktop and passing to another command as an RTFD, you could use the following:

        shortcuts run "Combine Images" -i ~/Desktop/*.jpg --output-type com.apple.rtfd | …

      • For a list of Uniform Type Indicators see System-Declared Uniform Type Identifiers.

      • The shortcuts command will exit 0 on a successful run or 1 on error.

    • Listing shortcuts on the command line

      • You can list all the shortcuts available using shortcuts list. You can also list shortcuts in custom folders. Use the -f flag and provide a custom folder name.

      • Note: You can only use the -f flag with custom folders, you cannot use generated folders such as “Quick Actions”, “Menu Bar” and so on.

      • To list all your folders instead of the shortcuts, you can use the following: shortcuts list --folders

    • Viewing shortcuts from the command line

      • You can open a shortcut in the editor using shortcuts view. This can be helpful in troubleshooting an errant shortcut.

    • Signing shortcuts from the command line

      You can sign a shortcut that you previously exported using shortcuts sign. When you sign a shortcut, Apple receives a copy for validation (to prevent unauthorised tampering when you share it). Shortcut signing has two modes:

      • Anyone: Anyone can import your shortcut.
      • People who know me: Only people who have you in their contacts will be able to import your shortcut. Your contact info will be included in the shortcut file.

      To sign a shortcut named “Share me”, use the following:

      shortcuts sign --mode people-who-know-me --input "Share me.shortcut" --output "Share me signed.shortcut"

      For information on sharing shortcuts, see Share shortcuts on Mac.

    • Though you can use x-callback-urls to run and view shortcuts from the command line, you should use the shortcuts command to be able to provide intelligent input and output. See Intro to URL schemes in Shortcuts on Mac.

  • https://support.apple.com/en-au/guide/shortcuts-mac/apda9578f70f/9.0/mac/26

    • Shortcut completion on Mac

    • If you expect that an action may create an issue, you can use the Stop Shortcut action or the Stop and Output action inside of an If action to halt the shortcut if a specific condition occurs. Stop actions are similar to a return or break statement in Swift.

      • Stop Shortcut: Stops the current shortcut. Place this action inside an If action to stop the shortcut when an if condition is true.

      • Stop and Output: Many shortcuts produce output content in the final action. However, some shortcuts do not yield a final output. In those shortcuts, you can add a Stop and Output action as the final action to stop the shortcut and output content that you designate in the action. You can also use this action inside of an If action to stop a shortcut early and provide an explanation for the stop. If a shortcut is one element of a more complicated automation, you can use the Stop and Output action to produce content that is handed off to the next element in the automation. If you run a shortcut from the share menu in iOS or iPadOS, or as a service in macOS, the output is sent to the app. If you run the shortcut from the Shortcuts app or outside of an app (from the Dock or menu bar, for example) and there is no place to send the output, you can choose one of the following:

        • Respond: The shortcut displays the content you designate in the Stop and Output action.
        • Do Nothing: The shortcut ends. No other actions are run.
        • Copy to Clipboard: The content is copied to the Clipboard.
  • https://support.apple.com/en-au/guide/shortcuts-mac/apd621a1ad7a/9.0/mac/26

    • Intro to URL schemes in Shortcuts on Mac

    • You can use URL schemes in Shortcuts. A URL scheme is the part of a link that specifies the type of application your device uses to open a URL.

    • Many apps support URL schemes: FaceTime uses URL schemes to make calls when a URL starting with facetime:// is opened, just like Safari handles URLs starting with http://.

    • You can also open URLs using schemes inside your shortcuts, provided by other apps. To do so, use the Open URL or Open X-Callback URL action.

  • https://support.apple.com/en-au/guide/shortcuts-mac/apda283236d7/9.0/mac/26

    • Open and create a shortcut using a URL scheme on Mac

    • The Shortcuts URL scheme allows you to open the app, create, run or edit a shortcut, and interact with the Gallery in the Shortcuts app. URL schemes can be used anywhere a URL can be used — your own app, in a web browser or in the command line.

    • Open Shortcuts using a URL scheme

      Open the URL shortcuts:// to launch the app to the state when it was last used.

    • Create a new shortcut using a URL scheme

      Open the URL shortcuts://create-shortcut to jump to the shortcut editor and to create a new shortcut.

    • Open a specific shortcut using a URL scheme

      You can launch the app to a particular shortcut in your collection.

      Open a URL with the following structure: shortcuts://open-shortcut?name=[name] and provide the name of the shortcut in the name parameter.

  • https://support.apple.com/en-au/guide/shortcuts-mac/apd624386f42/9.0/mac/26

    • Run a shortcut using a URL scheme on Mac

    • The Shortcuts URL scheme supports running a shortcut that’s saved in your shortcuts collection. This functionality may be useful in automation systems that extend beyond Shortcuts itself, so that other apps can run a shortcut in your collection. Or you could use the Shortcuts URL scheme in a task manager for running a shortcut as one step in a project. URL schemes can be used anywhere a URL can be used — your own app, in a web browser or in the command line.

    • Run a shortcut from a URL

      Open a URL with the following structure: shortcuts://run-shortcut?name=[name]&input=[input]&text=[text]

      Use the following parameters in the URL:

      • name: The name of the shortcut to run.
      • input (optional): The initial input into the shortcut. There are two input options: a text string or the word clipboard. When the input value is a text string, that text is used. When the input value is Clipboard, the contents of the clipboard are used.
      • text: If input is set to text, the value of the text parameter is passed as input to the shortcut. If input is set to clipboard, this parameter is ignored.

      By using a text string, you can provide your own URL-encoded text as input to the shortcut. For example, a URL that uses the text “goetta is great” as input to a shortcut named Lookup Goetta would look like this:

      shortcuts://run-shortcut?name=Lookup%20Goetta&input=text&text=goetta%20is%20great

      A URL to transfer the most recently copied text into a shortcut called Add to Notes would look like this:

      shortcuts://run-shortcut?name=Add%20to%20Notes&input=clipboard

    • Tip: If you’d like to run one shortcut from another shortcut, use the Run Shortcut action instead of a URL scheme. You should only run shortcuts with an URL if you’re integrating from another app outside of Shortcuts.

  • https://support.apple.com/en-au/guide/shortcuts-mac/apd9c112ca23/9.0/mac/26

    • Open or search the Shortcuts Gallery using a URL scheme on Mac

    • Shortcuts offers two URL scheme options for interacting with the Gallery: one for opening the Gallery and one for searching the Gallery. URL schemes can be used anywhere a URL can be used — your own app, in a web browser or in the command line.

    • Open the Gallery from a URL

      Open a URL with the following structure: shortcuts://gallery

      Shortcuts opens, showing you the main page of the Gallery.

    • Search the Gallery from a URL

      Open a URL with the following structure: shortcuts://gallery/search?query=[query]

      The query parameter determines the URL-encoded keywords to be searched in the Gallery.

      For example, if you want to send someone a link to explore shortcuts for photos available in the Gallery, you would instruct them to open

      shortcuts://gallery/search?query=photos

  • https://support.apple.com/en-au/guide/shortcuts-mac/apdcd7f20a6f/9.0/mac/26

    • Use x-callback-url with Shortcuts on Mac

    • Shortcuts supports x-callback-url, allowing the calling app to receive a response (a callback), when a particular interaction has completed. You can run shortcuts from an x-callback-url using the same parameters as discussed in Run a shortcut using a URL scheme on Mac.

      For example:

      shortcuts://x-callback-url/run-shortcut?name=Calculate%20Tip&input=text&text=24.99&x-success=...&x-cancel=...

      Per the X-Callback-URL standard, the following additional parameters can be provided:

      • x-success (optional): An URL that opens when the interaction is successful — for example, after a shortcut is imported or has finished running. If a shortcut is run, a parameter named result is appended to the URL and contains the textual output of the shortcut.
      • x-cancel (optional): An URL that opens when the interaction is cancelled by the user.
      • x-error (optional): An URL that opens when the interaction fails because an error occurred. A parameter named errorMessage is appended to the URL and contains a description of the error.

      With x-success, you can provide an URL that opens after the shortcut successfully finishes running. This could be used in conjunction with a multi-step checklist of tasks, wherein you open the x-callback-url to run a shortcut, return to the list and move on to the next task via URL.

      With x-cancel, you can provide a contingency URL to launch if the shortcut stops before it finishes running. Because the shortcut did not complete, no output from the shortcut is provided.

      With x-error, you can provide a contingency URL to launch if the shortcut encounters an error while running and fails to finish. In this case, you can fire up a different URL to handle the issue.

  • https://support.apple.com/en-au/guide/shortcuts-mac/apd68802640c/9.0/mac/26

    • Use another app’s URL scheme in Shortcuts on Mac

      Shortcuts also has the ability to integrate with other apps via their URL schemes. If you want to use an app that has URL schemes but isn’t currently supported with a built-in action, you can construct the URLs manually using the URL action and launch them using the Open URLs action or the Open X-Callback URL action.

      Note: Many URL schemes can be hard to implement and debug. The schemes often include a variety of parameters and require text to be URL encoded, which can be difficult to read. That said, exploring URL schemes does provide a deeper range of customisation beyond the built-in apps included in Shortcuts.

      Contact the developers of your favourite apps to see if they currently use an URL scheme, or ask them to implement URL schemes so you can automate their app in Shortcuts.

Alfred

BetterTouchTool

See Also:

Other Tools (Unsorted)

  • TODO

x-callback-url

System Preferences Panes

Unsorted

  • 0xdevalias/dotfiles#32

    • [bin] Create CLI helpers for triggering automation tools (Shortcuts, Alfred, BetterTouchTool, etc)

    • Add a unified CLI helper script (maybe also with lightweight shims/aliases) to trigger actions across workflow automation tools like Apple Shortcuts, Alfred, and BetterTouchTool.

      This would provide a consistent way to invoke automations from the terminal, while keeping tool-specific integrations (e.g. shortcuts run, bttcli, etc) easily accessible, while wrapping more complex integrations (e.g. Alfred external triggers) in a nice CLI tool.

      The goal is both discoverability and convenience — a single entrypoint for calling into each tool, plus optional aliases to make common actions more straightforward.

See Also

My Other Related Deepdive Gist's and Projects

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment