Give the remaining tray applets their modules, each with one start

openrazer (the official driver, daemon and library), polychromatic (the
AUR tray, kept as found; its i3 line moves out of the i3 module into its
own node-display-session contribution), forticlient (the AUR VPN client:
its service declared, its configuration never read) and nm-applet (the
desktop half of NetworkManager, apart from the server-side module).

The openrazer daemon fails on both workstations because the account is
not in the openrazer group; openrazer_check names it and the README
carries the one-off step, since the account's user resource is zsh's.

desktop.go learns to tell a program from another sharing its 15-character
command name, so polychromatic's tools never count or end themselves, and
a copies test holds the six carriers to one text.

modules/blueman/cmd/blueman-tools/desktop.go

@@ -1,8 +1,8 @@
 package main
 
-// desktop.go is the same file in the nextcloud-client, blueman and slack bundles: a
-// tray application of the operator's graphical session, seen from the node's tool runtime (novox/hq
-// ADR 0208).
+// desktop.go is the same file in every desktop application's bundle (copies_test.go names them and
+// holds them to one text): a tray application of the operator's graphical session, seen from the
+// node's tool runtime (novox/hq ADR 0208).
 //
 // The runtime is a system service running as the operator account (ADR 0175): it has the account's
 // uid and none of the session's environment. A tool that starts something on the desktop finds the
@@ -252,6 +252,22 @@ func (m *Machine) procs(comm string) []Proc {
 	return out
 }
 
+// procsOf are the account's processes named comm whose program is word. The kernel keeps 15
+// characters of a command name, so a longer name can share them with another program's: this bundle's
+// own binary among them (polychromatic-tools and polychromatic-tray-applet are both polychromatic-t).
+// The program is the first word of the command line, or the second for a script run by its
+// interpreter. An empty word keeps every process named comm.
+func (m *Machine) procsOf(comm, word string) []Proc {
+	var out []Proc
+	for _, p := range m.procs(comm) {
+		f := strings.Fields(p.Command)
+		if word == "" || (len(f) > 0 && filepath.Base(f[0]) == word) || (len(f) > 1 && filepath.Base(f[1]) == word) {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 // uidOf is the real uid on a process's status, -1 when unreadable.
 func (m *Machine) uidOf(dir string) int {
 	for _, l := range strings.Split(readTrimmed(filepath.Join(dir, "status")), "\n") {
@@ -412,12 +428,19 @@ func (m *Machine) detach(s Session, unit string, argv ...string) error {
 // stop ends every process of the account named in comms: SIGTERM, then SIGKILL for what is still
 // there after grace. It answers the pids that ended and those that had to be killed.
 func (m *Machine) stop(grace time.Duration, comms ...string) (ended, killed []int) {
-	var pids []int
+	var ps []Proc
 	for _, c := range comms {
-		for _, p := range m.procs(c) {
-			if m.Kill(p.PID, syscall.SIGTERM) == nil {
-				pids = append(pids, p.PID)
-			}
+		ps = append(ps, m.procs(c)...)
+	}
+	return m.stopProcs(grace, ps)
+}
+
+// stopProcs ends the processes given, as stop does.
+func (m *Machine) stopProcs(grace time.Duration, ps []Proc) (ended, killed []int) {
+	var pids []int
+	for _, p := range ps {
+		if m.Kill(p.PID, syscall.SIGTERM) == nil {
+			pids = append(pids, p.PID)
 		}
 	}
 	alive := func() []int {
@@ -452,10 +475,13 @@ func (m *Machine) stop(grace time.Duration, comms ...string) (ended, killed []in
 }
 
 // waitFor waits up to d for a process of the account named comm, and answers what it found.
-func (m *Machine) waitFor(comm string, d time.Duration) []Proc {
+func (m *Machine) waitFor(comm string, d time.Duration) []Proc { return m.waitForOf(comm, "", d) }
+
+// waitForOf waits up to d for a process of the account named comm whose program is word (procsOf).
+func (m *Machine) waitForOf(comm, word string, d time.Duration) []Proc {
 	step := 250 * time.Millisecond
 	for waited := time.Duration(0); ; waited += step {
-		if p := m.procs(comm); len(p) > 0 || waited >= d {
+		if p := m.procsOf(comm, word); len(p) > 0 || waited >= d {
 			return p
 		}
 		m.Sleep(step)