Welcome to the lab.

Bunch 1.4.8 was officially released this morning. It consists entirely of bug fixes that have been going through beta testing for a while now. Nothing groundbreaking, but some stuff that you probably didn’t know wasn’t working¹ is now working.

Some variable handling stuff:

• Variable keys passed from URL handler were running into case sensitivity issues
• Variables defined in a snippet call file line now work with conditional logic within the snippet (if var...)

Tagging stuff:

• When launching or quitting Bunches based on tags, %\tag was not ignoring the action on close
• Don’t inherit tags when nesting Bunches

Some general fixes:

• Allow retries when sending AppleScript commands for things like Hide Desktop and Hide Dock
• Ensure relaunch of Finder after hiding/showing desktop icons
• Modifier key mismatch in Select Editor tooltip

Grab the latest version from the download page (or just use Bunch->Check for Updates). Please keep the bug reports coming, and feel free to join the discussions if there are features you’d like to see.

I’ve always relied on 2-bit coloring for terminal output, sticking to eight foreground and eight background colors. It’s nice because it conforms to any user’s terminal theme. But there’s a whole world of colors out there (in most modern terminals) and I figured it was about time I started expanding my horizons.

I write most of my command line tools and scripts in Ruby. Call me old fashioned, but it really is a beautiful, readable language with plenty of room for elegant solutions. So this little snippet is in Ruby, but the core of it is simple enough that I can’t imagine it would take much work to port.

Like all terminal color output, it relies on ANSI escape codes. 2-bit escape codes look like \033[0;30;41m, which would be regular black text on a red background. But you can use RGB values in most modern terminals with an escape code like \033[38;2;RRR;GGG;BBBm (for a foreground color). So all you have to do is get RGB values for a specific color and insert them into that code.

The following Ruby snippet (gist here) will take a CSS hex color, e.g. #FA380E, and turn it into an ANSI escape sequence for you. It splits the hex value and uses the #hex method in Ruby to convert a 2-digit hex into a value between 1 and 256. With it you can run something like print "text to color".color256('#FA380E') and get some bright red text. The snippet itself is designed to be included in a script. If you run it directly you can test by using ./256color.rb "TEXT TO COLOR" "FG" "BG" where FG and BG are 3 or 6-digit hex codes. The octothorp (#) is always optional.

#!/usr/bin/env ruby
# frozen_string_literal: true

# 256-color hex interpretation for terminal colorization
#
# Usage
# "text".color256(foreground, background)
#
# print "Colorize this".color256('#f7921e', '#666')

# String category
module Color256
  def fg(fgc)
    "\x1b[38;2;#{fgc.rgb}m"
  end

  def bg(bgc)
    "\x1b[48;2;#{bgc.rgb}m"
  end

  def reset
    "\x1b[0m"
  end

  def rgb
    hex_string = sub(/^#?/, '')

    hex_string = hex_string.split(//).map { |a| a * 2 }.join('') if hex_string =~ /^#?[a-f0-9]{3}$/i

    parts = hex_string.match(/#?(?<r>..)(?<g>..)(?<b>..)/)
    t = []
    %w[r g b].each do |e|
      t << parts[e].hex
    end
    t.join(';')
  end

  def color256(fgc, bgc = nil)
    out = ''
    out += fg(fgc)
    out += bg(bgc) if bgc
    out += self
    out + reset
  end
end

class ::String
  include Color256
end

def test
  256.times do |r|
    256.times do |g|
      256.times do |b|
        c = ''
        [r, g, b].each { |comp| c += format('%02x', comp) }
        print ' '.color256('000', c)
      end
    end
  end
end

if __FILE__ == $0
  print ARGV[0].color256(ARGV[1], ARGV[2])
end

Hope that’s of use to somebody!

By the way, this is incorporated into the latest version of Doing such that you can use %#RRGGBB instead of a color name to set colors in a template. And use %b#RRGGBB to set a background color. Customize away!

I put some time into Bunch this weekend. It’s been a little while since I’ve worked on it — I haven’t needed it to do anything new lately, and the current release hasn’t had any major bug reports. So it’s been happily humming along. But there was one feature request that I did keep receiving and decided to take another look at.

The request is for support for Monterey’s focus modes. Bunch does a decent job of enabling and disabling Do Not Disturb, but the process is a hack that involves nested settings in PLIST data and toggling system daemons. I don’t love that I have to do that, but Apple provides no API for such settings. And I haven’t found a way (yet) to extend that hack to work with Focus Modes. So I offer a workaround: you can turn Focus Modes on and off using Shortcuts, and you can easily run Shortcuts in a Bunch using the shortcuts CLI.

1. Create two shortcuts for each focus mode you want to control from Bunch, one for turning on, and one for turning off.

2. Then, in a Bunch, you can use $ /usr/bin/shortcuts run "SHORTCUT_ON_NAME" (replacing SHORTCUT_ON_NAME with the name of the shortcut that turns the focus mode on), and !$ /usr/bin/shortcuts run "SHORTCUT_OFF_NAME". The combination of these two will turn the focus mode on when the Bunch opens, and off when it closes. You can, of course, reverse these as needed.

   $ /usr/bin/shortcuts run "Work Mode"
   !$ /usr/bin/shortcuts run "Work Mode Off"

3. There is no step 3.

Now when you open and close the Bunch, your desired Focus Mode will toggle on and off with it. It’s a couple extra steps beyond having a Bunch command to handle it, but I don’t foresee being able to incorporate them directly. Of course, I may just be missing something in the API that would make it possible without deep hacks, in which case I will definitely incorporate it.

Single Bunch Mode Grouping

Another request I got led to a couple of bug fixes. The following currently only works in the 2.4.8 beta (download here), but if testing goes well, it will be released to the stable version in short order.

What came up was the idea of having Single Bunch Mode apply to subsets of Bunches.

Single Bunch Mode can be enabled in preferences and simply means that when a Bunch opens, all other Bunches close, so you’re only running one at a time. Because Bunch is built for “context switching,” this makes switching your working context a single step. You can have any Bunch ignore Single Bunch Mode using frontmatter, so Bunches that should always be running can be easily excluded.

However, you might want to have multiple groups of Bunches where only one Bunch within the group is running at any given time. This can be accomplished with Bunch’s tagging features.

To tag a bunch, you just add frontmatter:

tags: work

Tag all of the Bunches in this subgroup with the same tag. Then, in each Bunch in the group, use the \tag syntax to act on the tag. Use ! to indicate you want to close the tagged Bunches, and include a % sign to ignore the directive when closing (so it doesn’t reverse it and reopen all of the tagged Bunches).

%!\work

This effectively gives you Single Bunch Mode for subsets of Bunches. If you ever want to do that, give it a shot.