1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
// dingger menu bar: live agent states from tmux pane user options
// (@agent / @agent_state), written by the dingger daemon.
//
// Design (per design panel): one question answered — "how many agents are
// waiting on me?" The status item is a bell plus the ready-queue depth;
// shape carries state (filled = needs you, outline = seen/calm, dotted =
// working); color is reserved for the tmux segment's blocked accent.
import AppKit
struct PaneRow {
let paneId: String
let target: String
let agent: String
let state: String
}
func symbol(_ name: String) -> NSImage? {
let image = NSImage(systemSymbolName: name, accessibilityDescription: nil)
return image?.withSymbolConfiguration(.init(pointSize: 13, weight: .regular))
}
func stateSymbol(_ state: String, queued: Bool) -> NSImage? {
switch (state, queued) {
case ("blocked", true): return symbol("exclamationmark.circle.fill")
case ("idle", true): return symbol("circle.fill")
case ("working", _): return symbol("circle.dotted") ?? symbol("hourglass")
case ("blocked", _): return symbol("exclamationmark.circle")
default: return symbol("circle")
}
}
final class Menubar: NSObject, NSApplicationDelegate, NSMenuDelegate {
private let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
private let menu = NSMenu()
private var panes: [PaneRow] = []
private var queue: [String] = [] // pane ids, oldest waiting first
func applicationDidFinishLaunching(_: Notification) {
NSApp.setActivationPolicy(.accessory) // no Dock icon
item.button?.image = symbol("bell")
item.button?.font = NSFont.monospacedDigitSystemFont(ofSize: 13, weight: .regular)
item.menu = menu
menu.delegate = self
let timer = Timer(timeInterval: 2.0, repeats: true) { [weak self] _ in
self?.refreshTitle()
}
RunLoop.main.add(timer, forMode: .common)
refreshTitle()
}
// MARK: data
private func runTmux(_ args: [String]) -> String? {
let process = Process()
process.executableURL = URL(fileURLWithPath: "/opt/homebrew/bin/tmux")
process.arguments = args
let pipe = Pipe()
process.standardOutput = pipe
process.standardError = FileHandle.nullDevice
do {
try process.run()
} catch {
return nil
}
let data = pipe.fileHandleForReading.readDataToEndOfFile()
process.waitUntilExit()
guard process.terminationStatus == 0 else { return nil }
return String(data: data, encoding: .utf8)
}
private func fetchPanes() -> [PaneRow] {
let fmt = "#{pane_id}\t#{session_name}:#{window_index}.#{pane_index}\t#{@agent}\t#{@agent_state}\t#{@dingger_ack}\t#{window_panes}"
guard let out = runTmux(["-u", "list-panes", "-a", "-F", fmt]) else { return [] }
return out.split(separator: "\n").compactMap { line in
let fields = line.split(separator: "\t", omittingEmptySubsequences: false)
guard fields.count >= 6 else { return nil }
let agent = String(fields[2])
let state = fields[3].isEmpty ? "unknown" : String(fields[3])
// Only tracked panes with a live state belong in the menu.
guard !agent.isEmpty, ["idle", "working", "blocked"].contains(state) else {
return nil
}
var target = "\(fields[1].split(separator: ".", maxSplits: 1).first ?? fields[1])"
if Int(fields[5]) ?? 1 > 1 {
target = String(fields[1])
}
return PaneRow(paneId: String(fields[0]), target: target, agent: agent, state: state)
}
}
private func fetchQueue() -> [String] {
guard let out = runTmux(["-u", "show-option", "-gv", "@dingger_queue"]) else { return [] }
return out.trimmingCharacters(in: .whitespacesAndNewlines)
.split(separator: ",").map { $0.split(separator: ":").first.map(String.init) ?? "" }
}
// MARK: title (timer-driven; never touches the open menu)
private func refreshTitle() {
panes = fetchPanes()
queue = fetchQueue()
let queued = panes.filter { row in queue.contains(row.paneId) }
let blocked = queued.filter { $0.state == "blocked" }.count
let working = panes.filter { $0.state == "working" }.count
let (name, count): (String, String)
if blocked > 0 {
(name, count) = ("bell.fill", String(queued.count))
} else if !queued.isEmpty {
(name, count) = ("bell", String(queued.count))
} else if working > 0 {
(name, count) = ("bell", "")
} else {
(name, count) = ("bell", "")
}
item.button?.image = symbol(name)
item.button?.title = count
var tip: [String] = []
if blocked > 0 { tip.append("\(blocked) blocked") }
if queued.count - blocked > 0 { tip.append("\(queued.count - blocked) waiting") }
if working > 0 { tip.append("\(working) working") }
let tipText = tip.isEmpty ? "Nothing waiting" : tip.joined(separator: " · ")
item.button?.toolTip = tipText
item.button?.setAccessibilityLabel("dingger, " + tipText)
}
// MARK: menu (rebuilt when opened, so rows don't reshuffle under the cursor)
func menuNeedsUpdate(_ menu: NSMenu) {
rebuildMenu()
}
private func rebuildMenu() {
menu.removeAllItems()
// Queue order (oldest waiting first), then the rest by target.
var ordered: [PaneRow] = []
for paneId in queue {
if let row = panes.first(where: { $0.paneId == paneId && $0.state != "working" }) {
ordered.append(row)
}
}
let orderedIds = ordered.map { $0.paneId }
let rest = panes
.filter { !orderedIds.contains($0.paneId) }
.sorted { $0.target < $1.target }
ordered.append(contentsOf: rest)
if panes.isEmpty {
let none = NSMenuItem(title: "No agents", action: nil, keyEquivalent: "")
none.isEnabled = false
menu.addItem(none)
}
var previousWaiting: Bool?
for pane in ordered {
let queued = queue.contains(pane.paneId)
let waiting = pane.state == "idle" || pane.state == "blocked"
// One separator between waiting agents and busy ones.
if let previous = previousWaiting, previous && !waiting {
menu.addItem(.separator())
}
previousWaiting = waiting
let row = NSMenuItem(title: "\(pane.agent)\t\(pane.target)",
action: #selector(paneClicked(_:)), keyEquivalent: "")
row.target = self
row.image = stateSymbol(pane.state, queued: queued)
row.attributedTitle = attributedRow(agent: pane.agent, target: pane.target)
row.toolTip = "\(pane.state) — \(pane.target)"
row.representedObject = pane.paneId
menu.addItem(row)
}
menu.addItem(.separator())
let quit = NSMenuItem(title: "Quit dingger", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
menu.addItem(quit)
}
/// Agent left, tmux target right-aligned at a computed tab stop — like a
/// native menu's key-equivalent column.
private func attributedRow(agent: String, target: String) -> NSAttributedString {
let menuFont = NSFont.menuFont(ofSize: 0)
let monoFont = NSFont.monospacedSystemFont(
ofSize: menuFont.pointSize - 1, weight: .regular)
let agentWidth = (agent as NSString).size(withAttributes: [.font: menuFont]).width
let targetWidth = (target as NSString).size(withAttributes: [.font: monoFont]).width
let tabStop = ceil(agentWidth + 40 + targetWidth)
let paragraph = NSMutableParagraphStyle()
paragraph.tabStops = [NSTextTab(textAlignment: .right, location: tabStop)]
let text = NSMutableAttributedString()
text.append(NSAttributedString(
string: agent,
attributes: [.font: menuFont, .paragraphStyle: paragraph]))
text.append(NSAttributedString(string: "\t"))
text.append(NSAttributedString(
string: target,
attributes: [.font: monoFont, .paragraphStyle: paragraph]))
return text
}
// MARK: actions
@objc private func paneClicked(_ sender: NSMenuItem) {
guard let paneId = sender.representedObject as? String else { return }
// Ack like `dingger focus` does, so both counts drop together.
_ = runTmux(["-u", "set-option", "-p", "-t", paneId, "@dingger_ack", "1"])
let target = panes.first { $0.paneId == paneId }?.target ?? ""
guard !target.isEmpty else { return }
_ = runTmux(["-u", "switch-client", "-t", target])
for bundle in ["com.mitchellh.ghostty", "org.alacritty", "com.apple.Terminal"] {
if let app = NSRunningApplication.runningApplications(withBundleIdentifier: bundle).first {
app.activate()
break
}
}
}
}
let app = NSApplication.shared
let delegate = Menubar()
app.delegate = delegate
app.setActivationPolicy(.accessory)
app.run()
|
