Headspace v2.0: Simple and Headless

> hs.inspect(hs.fs.tagsGet(hs.application.find("Kitty"):path()))
2023-02-16 15:16:03: -- Loading extension: inspect
{ "coding" }

-- Module:start() is a convention for starting a Spoon
function m:start()
  -- m.watcher fires every time an application event occurs
  m.watcher = hs.application.watcher.new(function(appName, event, hsapp)
    -- but we only care about applications launching!
    if event == hs.application.watcher.launched then
      -- this conditional is the *soul* of the program.
      if not m.allowed(hsapp) then
        -- show a nag alert
        hs.alert(
          "🛑: " .. hsapp:name(),
          moduleStyle
        )
        hsapp:kill()
      end
    end
  end):start()

  -- configure the URL events and tie them to the right callbacks.
  hs.urlevent.bind("setBlacklist", m.setBlacklist)
  hs.urlevent.bind("setWhitelist", m.setWhitelist)
  hs.urlevent.bind("stopHeadspace", m.stopHeadspace)

  return self
end

function m.setWhitelist(_eventName, params)
  local list = {}

  -- parse out the tags and apps, potential params to the URL.
  if params["tags"] then
    list["tags"] = fn.split(params["tags"], ",")
  end
  if params["apps"] then
    list["apps"] = fn.split(params["apps"], ",")
  end

  -- set the settings variable to the parsed table
  hs.settings.set("headspace", { ["whitelist"] = list })

  -- listen for a special parameter and (if true) kill apps that match
  -- the rule based on the settings variable we just saved.
  if params["kill"] then
    m.killBlockedDockedApps()
  end
end

m.allowed = function(app)
  -- get the tags on the filesystem for this app
  local tags = hs.fs.tagsGet(app:path())
  local name = app:name()

  -- if it has the tag `whitelisted`, allow!
  if tags and fn.contains(tags, "whitelisted") then
    return true
  end

  if m.getWhitelist() then
    -- assume the app **is blocked** by tag and name
    local appAllowed = false
    local tagAllowed = false

    if m.getWhitelist().apps then
      -- if the apps list contains this app's name, allow!
      appAllowed = fn.contains(m.getWhitelist().apps, name)
    end
    if m.getWhitelist().tags and tags then
      -- if there's an intersection between application tags and rule tags, allow!
      tagAllowed = fn.some(m.getWhitelist().tags, function(tag)
        return fn.contains(tags, tag)
      end)
    end

    -- whitelist allows if the tag is allowed or the name is allowed.
    return tagAllowed or appAllowed
  end

  if m.getBlacklist() then
    -- assume that this app is **not blocked** by tag or name
    local appBlocked = false
    local tagBlocked = false

    -- if the rule contains application names
    if m.getBlacklist().apps then
      -- if the name matches, block!
      appBlocked = fn.contains(m.getBlacklist().apps, name)
    end

    if m.getBlacklist().tags and tags then
      -- if there's an intersection, block!
      tagBlocked = fn.some(m.getBlacklist().tags, function(tag)
        return fn.contains(tags, tag)
      end)
    end

    -- if the app is not blocked by name or tags… true.
    return (not appBlocked) and (not tagBlocked)
  end

  return true
end

m.dockedAndNotFinder = function(app)
  return app:bundleID() ~= "com.apple.finder" and app:kind() == 1
end

m.killBlockedDockedApps = function()
  local dockedAndBlocked =
    fn.filter(hs.application.runningApplications(), function(app)
      return m.dockedAndNotFinder(app) and not m.allowed(app)
    end)

  fn.each(dockedAndBlocked, function(app) app:kill() end)
end