bdeshiandClaude Sonnet 5
79395ef9d6
Lets someone skip the startup picker entirely; the first time it would've shown with nothing running, a small popover on the menu bar icon points there instead, then never again. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
766 lines
34 KiB
Swift
766 lines
34 KiB
Swift
// One ordinary, non-modal window for everything profile-management related
|
|
// — replaces what would otherwise be a string of separate popup alerts.
|
|
// Opened from the menu bar's "Manage Profiles…" item or the standard
|
|
// Cmd+, shortcut. Fixed-size (not user-resizable) — each tab reports its
|
|
// own natural size via preferredContentSize, and NSTabViewController
|
|
// resizes the window to match automatically, so it's never left showing
|
|
// empty space sized for a different tab or state.
|
|
import AppKit
|
|
|
|
final class ManageWindowController: NSWindowController {
|
|
static let shared = ManageWindowController()
|
|
|
|
enum Tab: Int { case profiles = 0, settings = 1, about = 2 }
|
|
|
|
private let profilesVC = ProfilesViewController()
|
|
private let settingsVC = SettingsViewController()
|
|
private let aboutVC = AboutViewController()
|
|
private let tabs = NSTabViewController()
|
|
|
|
// Called after a profile is added/removed so the caller can trigger an
|
|
// immediate LiveState reconcile instead of waiting on the next
|
|
// notification.
|
|
var onProfilesChanged: (() -> Void)? {
|
|
didSet { profilesVC.onChange = onProfilesChanged }
|
|
}
|
|
|
|
// Called when the window-tag style changes, so open tags can be
|
|
// rebuilt in the new style immediately rather than at the next
|
|
// launch/quit of a Claude window.
|
|
var onOverlayStyleChanged: (() -> Void)? {
|
|
didSet { settingsVC.onOverlayStyleChanged = onOverlayStyleChanged }
|
|
}
|
|
|
|
private init() {
|
|
let window = NSWindow(
|
|
contentRect: NSRect(x: 0, y: 0, width: 420, height: 260),
|
|
styleMask: [.titled, .closable, .miniaturizable],
|
|
backing: .buffered, defer: false)
|
|
window.title = "shannoncoat"
|
|
window.isReleasedWhenClosed = false
|
|
window.center()
|
|
|
|
profilesVC.title = "Profiles"
|
|
settingsVC.title = "Settings"
|
|
aboutVC.title = "About"
|
|
tabs.addTabViewItem(NSTabViewItem(viewController: profilesVC))
|
|
tabs.addTabViewItem(NSTabViewItem(viewController: settingsVC))
|
|
tabs.addTabViewItem(NSTabViewItem(viewController: aboutVC))
|
|
window.contentViewController = tabs
|
|
|
|
super.init(window: window)
|
|
}
|
|
|
|
required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
|
|
|
|
func show(tab: Tab? = nil) {
|
|
NSApp.activate(ignoringOtherApps: true)
|
|
if let tab {
|
|
tabs.selectedTabViewItemIndex = tab.rawValue
|
|
}
|
|
window?.makeKeyAndOrderFront(nil)
|
|
}
|
|
|
|
func update(_ infos: [ProfileInfo]) {
|
|
profilesVC.update(infos)
|
|
}
|
|
}
|
|
|
|
// MARK: - Profiles tab
|
|
|
|
private final class ProfilesViewController: NSViewController, NSTableViewDataSource, NSTableViewDelegate,
|
|
NSTextFieldDelegate
|
|
{
|
|
var onChange: (() -> Void)?
|
|
|
|
private var infos: [ProfileInfo] = []
|
|
private let tableView = NSTableView()
|
|
private let addRemoveControl = NSSegmentedControl()
|
|
private let detailStack = NSStackView()
|
|
private let detailAppValue = NSTextField(labelWithString: "")
|
|
private let detailCodeValue = NSTextField(labelWithString: "")
|
|
private let detailAppCopyItem = NSMenuItem(title: "Copy Path", action: #selector(copyDetailPath(_:)), keyEquivalent: "")
|
|
private let detailCodeCopyItem = NSMenuItem(title: "Copy Path", action: #selector(copyDetailPath(_:)), keyEquivalent: "")
|
|
private let addForm = NSStackView()
|
|
private let nameField = NSTextField()
|
|
private let codeField = NSTextField()
|
|
private let appField = NSTextField()
|
|
private let errorLabel = NSTextField(labelWithString: "")
|
|
private var outerStack: NSStackView!
|
|
private var scrollHeightConstraint: NSLayoutConstraint!
|
|
|
|
private static let margin: CGFloat = 20
|
|
private static let tableWidth: CGFloat = 340
|
|
private static let minVisibleRows = 3
|
|
private static let maxVisibleRows = 8
|
|
|
|
override func loadView() {
|
|
view = NSView(frame: NSRect(x: 0, y: 0, width: 420, height: 260))
|
|
|
|
let column = NSTableColumn(identifier: .init("profile"))
|
|
column.title = "Profile"
|
|
column.width = 340
|
|
tableView.addTableColumn(column)
|
|
tableView.headerView = nil
|
|
tableView.dataSource = self
|
|
tableView.delegate = self
|
|
tableView.rowHeight = 24
|
|
tableView.usesAlternatingRowBackgroundColors = true
|
|
tableView.menu = buildContextMenu()
|
|
|
|
let scroll = NSScrollView()
|
|
scroll.documentView = tableView
|
|
scroll.hasVerticalScroller = true
|
|
scroll.borderType = .bezelBorder
|
|
scroll.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
addRemoveControl.segmentCount = 2
|
|
addRemoveControl.trackingMode = .momentary
|
|
addRemoveControl.segmentStyle = .smallSquare
|
|
addRemoveControl.setImage(NSImage(systemSymbolName: "plus", accessibilityDescription: "Add Profile"), forSegment: 0)
|
|
addRemoveControl.setImage(
|
|
NSImage(systemSymbolName: "minus", accessibilityDescription: "Remove Profile"), forSegment: 1)
|
|
addRemoveControl.setWidth(28, forSegment: 0)
|
|
addRemoveControl.setWidth(28, forSegment: 1)
|
|
addRemoveControl.setEnabled(false, forSegment: 1)
|
|
addRemoveControl.setToolTip("Add Profile", forSegment: 0)
|
|
addRemoveControl.setToolTip("Remove Profile", forSegment: 1)
|
|
addRemoveControl.target = self
|
|
addRemoveControl.action = #selector(addRemoveClicked(_:))
|
|
let buttonRow = NSStackView(views: [addRemoveControl, NSView()])
|
|
buttonRow.orientation = .horizontal
|
|
buttonRow.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
buildDetailStack()
|
|
detailStack.isHidden = true
|
|
detailStack.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
buildAddForm()
|
|
addForm.isHidden = true
|
|
addForm.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
let stack = NSStackView(views: [scroll, buttonRow, detailStack, addForm])
|
|
stack.orientation = .vertical
|
|
stack.spacing = 12
|
|
stack.edgeInsets = NSEdgeInsets(top: Self.margin, left: Self.margin, bottom: Self.margin, right: Self.margin)
|
|
stack.translatesAutoresizingMaskIntoConstraints = false
|
|
view.addSubview(stack)
|
|
outerStack = stack
|
|
scrollHeightConstraint = scroll.heightAnchor.constraint(equalToConstant: heightForRows(0))
|
|
|
|
NSLayoutConstraint.activate([
|
|
stack.topAnchor.constraint(equalTo: view.topAnchor),
|
|
stack.leadingAnchor.constraint(equalTo: view.leadingAnchor),
|
|
stack.trailingAnchor.constraint(equalTo: view.trailingAnchor),
|
|
stack.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
scroll.widthAnchor.constraint(equalToConstant: Self.tableWidth),
|
|
scrollHeightConstraint,
|
|
// `scroll` is the one arranged subview with a real, absolute
|
|
// width — everything else in this stack ties its width to
|
|
// *that*, not to `stack` itself (whose own frame spans
|
|
// edge-to-edge; edgeInsets only govern how the stack lays out
|
|
// its children, not its own bounds). Left unconstrained, these
|
|
// rows have no hard width anywhere in their constraint chain —
|
|
// NSStackView doesn't fill them to the inset content width by
|
|
// default, so they end up sized/positioned ambiguously (in
|
|
// practice: flush against the window edge, sometimes wider
|
|
// than the window).
|
|
buttonRow.widthAnchor.constraint(equalTo: scroll.widthAnchor),
|
|
detailStack.widthAnchor.constraint(equalTo: scroll.widthAnchor),
|
|
addForm.widthAnchor.constraint(equalTo: scroll.widthAnchor),
|
|
])
|
|
|
|
updatePreferredSize()
|
|
}
|
|
|
|
// Sized to the actual row count (clamped to a sensible range) rather
|
|
// than one fixed height — with only a couple of profiles that avoids a
|
|
// big block of empty striped background below the last row; with many
|
|
// it caps out and scrolls instead of taking over the window.
|
|
private func heightForRows(_ count: Int) -> CGFloat {
|
|
let rows = max(Self.minVisibleRows, min(count, Self.maxVisibleRows))
|
|
return CGFloat(rows) * tableView.rowHeight + 2
|
|
}
|
|
|
|
// NSTabViewController watches its selected child's preferredContentSize
|
|
// and resizes the window to match live — so recomputing this after
|
|
// toggling the add form or the path-details row is what makes the
|
|
// window grow/shrink to fit instead of sitting at one fixed size with
|
|
// empty space in the states that don't need it.
|
|
private func updatePreferredSize() {
|
|
view.layoutSubtreeIfNeeded()
|
|
preferredContentSize = outerStack.fittingSize
|
|
}
|
|
|
|
// A second, authoritative recompute after every real layout pass —
|
|
// explicit calls from action handlers (below) update it eagerly for
|
|
// responsiveness, but this is the one that can't be thrown off by
|
|
// metrics not being fully resolved yet at the point an eager call runs.
|
|
override func viewDidLayout() {
|
|
super.viewDidLayout()
|
|
preferredContentSize = outerStack.fittingSize
|
|
}
|
|
|
|
// Shows the selected profile's two dirs — the thing you'd otherwise
|
|
// have to right-click "Reveal" to find out. Not `.isSelectable` — that
|
|
// makes a label click-into-edit, and the field editor that appears
|
|
// draws the *untruncated* string at its full intrinsic width, which
|
|
// can extend past the window and get clipped by it rather than
|
|
// wrapping or scrolling cleanly. A tooltip (full path) plus a
|
|
// right-click "Copy Path" menu covers the same "get the value out"
|
|
// need without that.
|
|
private func buildDetailStack() {
|
|
detailAppCopyItem.target = self
|
|
detailCodeCopyItem.target = self
|
|
let appMenu = NSMenu()
|
|
appMenu.addItem(detailAppCopyItem)
|
|
let codeMenu = NSMenu()
|
|
codeMenu.addItem(detailCodeCopyItem)
|
|
|
|
for (value, menu) in [(detailAppValue, appMenu), (detailCodeValue, codeMenu)] {
|
|
value.textColor = .secondaryLabelColor
|
|
value.font = .systemFont(ofSize: NSFont.smallSystemFontSize)
|
|
value.lineBreakMode = .byTruncatingMiddle
|
|
value.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
|
|
value.menu = menu
|
|
}
|
|
|
|
let appRow = NSStackView(views: [labeled("Claude Desktop:"), detailAppValue])
|
|
appRow.orientation = .horizontal
|
|
appRow.spacing = 8
|
|
let codeRow = NSStackView(views: [labeled("Claude Code:"), detailCodeValue])
|
|
codeRow.orientation = .horizontal
|
|
codeRow.spacing = 8
|
|
|
|
detailStack.orientation = .vertical
|
|
detailStack.alignment = .leading
|
|
detailStack.spacing = 4
|
|
[appRow, codeRow].forEach(detailStack.addArrangedSubview)
|
|
appRow.widthAnchor.constraint(equalTo: detailStack.widthAnchor).isActive = true
|
|
codeRow.widthAnchor.constraint(equalTo: detailStack.widthAnchor).isActive = true
|
|
}
|
|
|
|
private func buildAddForm() {
|
|
nameField.placeholderString = "Profile name"
|
|
nameField.delegate = self
|
|
|
|
for field in [codeField, appField] {
|
|
field.lineBreakMode = .byTruncatingMiddle
|
|
field.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
|
|
}
|
|
|
|
codeField.placeholderString = "~/.shannoncoat/data/<name>/code"
|
|
let codeChoose = NSButton(title: "Choose\u{2026}", target: self, action: #selector(chooseCodeDir))
|
|
let codeRow = NSStackView(views: [labeled("Claude Code:"), codeField, codeChoose])
|
|
codeRow.orientation = .horizontal
|
|
codeRow.spacing = 8
|
|
|
|
appField.placeholderString = "~/.shannoncoat/data/<name>/app"
|
|
let appChoose = NSButton(title: "Choose\u{2026}", target: self, action: #selector(chooseAppDir))
|
|
let appRow = NSStackView(views: [labeled("Claude Desktop:"), appField, appChoose])
|
|
appRow.orientation = .horizontal
|
|
appRow.spacing = 8
|
|
|
|
errorLabel.textColor = .systemRed
|
|
errorLabel.font = .systemFont(ofSize: NSFont.smallSystemFontSize)
|
|
errorLabel.maximumNumberOfLines = 0
|
|
errorLabel.lineBreakMode = .byWordWrapping
|
|
|
|
let createButton = NSButton(title: "Create", target: self, action: #selector(createProfile))
|
|
createButton.keyEquivalent = "\r"
|
|
let cancelButton = NSButton(title: "Cancel", target: self, action: #selector(toggleAddForm))
|
|
let formButtonRow = NSStackView(views: [NSView(), cancelButton, createButton])
|
|
formButtonRow.orientation = .horizontal
|
|
formButtonRow.spacing = 8
|
|
|
|
let divider = NSBox()
|
|
divider.boxType = .separator
|
|
|
|
addForm.orientation = .vertical
|
|
addForm.alignment = .leading
|
|
addForm.spacing = 10
|
|
[divider, nameField, codeRow, appRow, errorLabel, formButtonRow].forEach(addForm.addArrangedSubview)
|
|
divider.widthAnchor.constraint(equalTo: addForm.widthAnchor).isActive = true
|
|
nameField.widthAnchor.constraint(equalTo: addForm.widthAnchor).isActive = true
|
|
codeRow.widthAnchor.constraint(equalTo: addForm.widthAnchor).isActive = true
|
|
appRow.widthAnchor.constraint(equalTo: addForm.widthAnchor).isActive = true
|
|
formButtonRow.widthAnchor.constraint(equalTo: addForm.widthAnchor).isActive = true
|
|
}
|
|
|
|
// Fixed-width, trailing-aligned label so the fields in a two-row form
|
|
// (differing label lengths: "Claude Code:" vs "Claude Desktop:") start
|
|
// at the same x position instead of a ragged left edge.
|
|
private func labeled(_ text: String) -> NSTextField {
|
|
let field = NSTextField(labelWithString: text)
|
|
field.font = .systemFont(ofSize: NSFont.systemFontSize)
|
|
field.textColor = .secondaryLabelColor
|
|
field.setContentHuggingPriority(.required, for: .horizontal)
|
|
field.alignment = .right
|
|
field.widthAnchor.constraint(equalToConstant: 104).isActive = true
|
|
return field
|
|
}
|
|
|
|
func update(_ infos: [ProfileInfo]) {
|
|
self.infos = infos
|
|
tableView.reloadData()
|
|
scrollHeightConstraint.constant = heightForRows(infos.count)
|
|
refreshForSelection()
|
|
}
|
|
|
|
private func refreshForSelection() {
|
|
let row = tableView.selectedRow
|
|
guard infos.indices.contains(row) else {
|
|
addRemoveControl.setEnabled(false, forSegment: 1)
|
|
detailStack.isHidden = true
|
|
updatePreferredSize()
|
|
return
|
|
}
|
|
let profile = infos[row].profile
|
|
addRemoveControl.setEnabled(profile.name != "default", forSegment: 1)
|
|
detailAppValue.stringValue = profile.appDir
|
|
detailAppValue.toolTip = profile.appDir
|
|
detailAppCopyItem.representedObject = profile.appDir
|
|
detailCodeValue.stringValue = profile.codeDir
|
|
detailCodeValue.toolTip = profile.codeDir
|
|
detailCodeCopyItem.representedObject = profile.codeDir
|
|
detailStack.isHidden = false
|
|
updatePreferredSize()
|
|
}
|
|
|
|
@objc private func copyDetailPath(_ sender: NSMenuItem) {
|
|
guard let path = sender.representedObject as? String else { return }
|
|
NSPasteboard.general.clearContents()
|
|
NSPasteboard.general.setString(path, forType: .string)
|
|
}
|
|
|
|
// MARK: NSTableViewDataSource / Delegate
|
|
|
|
func numberOfRows(in tableView: NSTableView) -> Int { infos.count }
|
|
|
|
func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
|
|
let identifier = NSUserInterfaceItemIdentifier("profileCell")
|
|
let info = infos[row]
|
|
let cell: NSTableCellView
|
|
if let reused = tableView.makeView(withIdentifier: identifier, owner: self) as? NSTableCellView {
|
|
cell = reused
|
|
} else {
|
|
cell = NSTableCellView()
|
|
cell.identifier = identifier
|
|
let imageView = NSImageView()
|
|
let textField = NSTextField(labelWithString: "")
|
|
imageView.translatesAutoresizingMaskIntoConstraints = false
|
|
textField.translatesAutoresizingMaskIntoConstraints = false
|
|
cell.addSubview(imageView)
|
|
cell.addSubview(textField)
|
|
cell.imageView = imageView
|
|
cell.textField = textField
|
|
NSLayoutConstraint.activate([
|
|
imageView.leadingAnchor.constraint(equalTo: cell.leadingAnchor, constant: 6),
|
|
imageView.centerYAnchor.constraint(equalTo: cell.centerYAnchor),
|
|
imageView.widthAnchor.constraint(equalToConstant: 10),
|
|
imageView.heightAnchor.constraint(equalToConstant: 10),
|
|
textField.leadingAnchor.constraint(equalTo: imageView.trailingAnchor, constant: 8),
|
|
textField.trailingAnchor.constraint(lessThanOrEqualTo: cell.trailingAnchor, constant: -6),
|
|
textField.centerYAnchor.constraint(equalTo: cell.centerYAnchor),
|
|
])
|
|
}
|
|
cell.imageView?.image = ProfileColor.dotImage(for: info.profile.name, dimmed: !info.running)
|
|
|
|
let text = NSMutableAttributedString(
|
|
string: info.profile.name, attributes: [.font: NSFont.systemFont(ofSize: NSFont.systemFontSize)])
|
|
text.append(NSAttributedString(
|
|
string: " \(info.running ? "Running" : "Stopped")",
|
|
attributes: [
|
|
.font: NSFont.systemFont(ofSize: NSFont.smallSystemFontSize),
|
|
.foregroundColor: NSColor.secondaryLabelColor,
|
|
]))
|
|
cell.textField?.attributedStringValue = text
|
|
return cell
|
|
}
|
|
|
|
func tableViewSelectionDidChange(_ notification: Notification) {
|
|
refreshForSelection()
|
|
}
|
|
|
|
// MARK: NSTextFieldDelegate — live default-path preview as the name is typed
|
|
|
|
func controlTextDidChange(_ obj: Notification) {
|
|
guard (obj.object as? NSTextField) === nameField else { return }
|
|
let name = nameField.stringValue.isEmpty ? "<name>" : nameField.stringValue
|
|
codeField.placeholderString = "~/.shannoncoat/data/\(name)/code"
|
|
appField.placeholderString = "~/.shannoncoat/data/\(name)/app"
|
|
}
|
|
|
|
// MARK: Actions
|
|
|
|
@objc private func addRemoveClicked(_ sender: NSSegmentedControl) {
|
|
switch sender.selectedSegment {
|
|
case 0: toggleAddForm()
|
|
case 1: removeSelected()
|
|
default: break
|
|
}
|
|
}
|
|
|
|
@objc private func toggleAddForm() {
|
|
addForm.isHidden.toggle()
|
|
if !addForm.isHidden {
|
|
nameField.stringValue = ""
|
|
codeField.stringValue = ""
|
|
appField.stringValue = ""
|
|
errorLabel.stringValue = ""
|
|
view.window?.makeFirstResponder(nameField)
|
|
}
|
|
updatePreferredSize()
|
|
}
|
|
|
|
@objc private func chooseCodeDir() { choose(into: codeField) }
|
|
@objc private func chooseAppDir() { choose(into: appField) }
|
|
|
|
private func choose(into field: NSTextField) {
|
|
let panel = NSOpenPanel()
|
|
panel.canChooseDirectories = true
|
|
panel.canChooseFiles = false
|
|
panel.allowsMultipleSelection = false
|
|
guard let window = view.window else { return }
|
|
panel.beginSheetModal(for: window) { response in
|
|
if response == .OK, let url = panel.url {
|
|
field.stringValue = url.path
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc private func createProfile() {
|
|
let name = nameField.stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let code = codeField.stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let app = appField.stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
do {
|
|
try ProfileStore.create(name: name, codeDir: code.isEmpty ? nil : code, appDir: app.isEmpty ? nil : app)
|
|
toggleAddForm()
|
|
onChange?()
|
|
} catch {
|
|
errorLabel.stringValue = (error as? LocalizedError)?.errorDescription ?? "\(error)"
|
|
updatePreferredSize()
|
|
}
|
|
}
|
|
|
|
@objc private func removeSelected() {
|
|
let row = tableView.selectedRow
|
|
guard infos.indices.contains(row) else { return }
|
|
let info = infos[row]
|
|
guard info.profile.name != "default", let window = view.window else { return }
|
|
|
|
let alert = NSAlert()
|
|
alert.alertStyle = .warning
|
|
alert.messageText = "Delete profile \u{201C}\(info.profile.name)\u{201D}?"
|
|
alert.informativeText = info.running
|
|
? "This profile is currently running \u{2014} deleting it will quit Claude first. Its Claude Desktop and Claude Code data stay on disk; only the profile pointer is removed."
|
|
: "Its Claude Desktop and Claude Code data stay on disk; only the profile pointer is removed."
|
|
alert.addButton(withTitle: "Delete")
|
|
alert.addButton(withTitle: "Cancel")
|
|
alert.buttons.first?.hasDestructiveAction = true
|
|
|
|
alert.beginSheetModal(for: window) { [weak self] response in
|
|
guard response == .alertFirstButtonReturn else { return }
|
|
let finish = {
|
|
try? ProfileStore.delete(info.profile.name)
|
|
self?.onChange?()
|
|
}
|
|
if info.running, let pid = info.pid {
|
|
ClaudeControl.quit(pid: pid) { _ in DispatchQueue.main.async(execute: finish) }
|
|
} else {
|
|
finish()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func buildContextMenu() -> NSMenu {
|
|
let menu = NSMenu()
|
|
let revealCode = NSMenuItem(title: "Reveal Code Folder", action: #selector(revealCodeDir), keyEquivalent: "")
|
|
revealCode.target = self
|
|
let revealApp = NSMenuItem(
|
|
title: "Reveal Desktop Folder", action: #selector(revealAppDir), keyEquivalent: "")
|
|
revealApp.target = self
|
|
menu.addItem(revealCode)
|
|
menu.addItem(revealApp)
|
|
return menu
|
|
}
|
|
|
|
private func clickedInfo() -> ProfileInfo? {
|
|
let row = tableView.clickedRow
|
|
guard infos.indices.contains(row) else { return nil }
|
|
return infos[row]
|
|
}
|
|
|
|
@objc private func revealCodeDir() {
|
|
guard let info = clickedInfo() else { return }
|
|
NSWorkspace.shared.selectFile(nil, inFileViewerRootedAtPath: info.profile.codeDir)
|
|
}
|
|
|
|
@objc private func revealAppDir() {
|
|
guard let info = clickedInfo() else { return }
|
|
NSWorkspace.shared.selectFile(nil, inFileViewerRootedAtPath: info.profile.appDir)
|
|
}
|
|
}
|
|
|
|
// MARK: - Settings tab
|
|
|
|
private final class SettingsViewController: NSViewController {
|
|
private let autoUpdateCheckbox = NSButton(
|
|
checkboxWithTitle: "Automatically check for updates", target: nil, action: nil)
|
|
private let launchAtLoginCheckbox = NSButton(checkboxWithTitle: "Launch at Login", target: nil, action: nil)
|
|
private let hideStartupPickerCheckbox = NSButton(
|
|
checkboxWithTitle: "Hide the startup picker when no profiles are running", target: nil, action: nil)
|
|
private let checkNowButton = NSButton(title: "Check for Updates\u{2026}", target: nil, action: nil)
|
|
private let tagStyleLabel = NSTextField(labelWithString: "Window tag:")
|
|
private let tagStylePopUp = NSPopUpButton(frame: .zero, pullsDown: false)
|
|
private var tagStyleRow: NSStackView!
|
|
private let clickActionLabel = NSTextField(labelWithString: "Click a profile to:")
|
|
private let clickActionPopUp = NSPopUpButton(frame: .zero, pullsDown: false)
|
|
private var clickActionRow: NSStackView!
|
|
private var stack: NSStackView!
|
|
|
|
var onOverlayStyleChanged: (() -> Void)?
|
|
|
|
// Order matches the popup's items, so the selected index maps straight
|
|
// onto a style without a title-string comparison.
|
|
private static let tagStyles: [(title: String, style: WindowOverlayStyle)] = [
|
|
("Name chip", .chip),
|
|
("Colored dot", .dot),
|
|
]
|
|
|
|
// Same index-to-value arrangement. Each title spells out the Shift-click
|
|
// half too: the two actions always swap together, so showing only the
|
|
// plain click's half would leave the other looking unset.
|
|
private static let clickActions: [(title: String, action: MenuClickAction)] = [
|
|
("Switch to it (\u{21e7}: open alongside)", .switchTo),
|
|
("Open it alongside (\u{21e7}: switch to it)", .openAlongside),
|
|
]
|
|
|
|
override func loadView() {
|
|
view = NSView(frame: NSRect(x: 0, y: 0, width: 420, height: 150))
|
|
|
|
tagStylePopUp.addItems(withTitles: Self.tagStyles.map(\.title))
|
|
tagStylePopUp.selectItem(at: Self.tagStyles.firstIndex { $0.style == WindowOverlayPosition.style } ?? 0)
|
|
tagStylePopUp.target = self
|
|
tagStylePopUp.action = #selector(changeTagStyle)
|
|
|
|
tagStyleRow = NSStackView(views: [tagStyleLabel, tagStylePopUp])
|
|
tagStyleRow.orientation = .horizontal
|
|
tagStyleRow.spacing = 8
|
|
|
|
clickActionPopUp.addItems(withTitles: Self.clickActions.map(\.title))
|
|
clickActionPopUp.selectItem(
|
|
at: Self.clickActions.firstIndex { $0.action == MenuClickBehavior.plainClick } ?? 0)
|
|
clickActionPopUp.target = self
|
|
clickActionPopUp.action = #selector(changeClickAction)
|
|
|
|
clickActionRow = NSStackView(views: [clickActionLabel, clickActionPopUp])
|
|
clickActionRow.orientation = .horizontal
|
|
clickActionRow.spacing = 8
|
|
|
|
launchAtLoginCheckbox.target = self
|
|
launchAtLoginCheckbox.action = #selector(toggleLaunchAtLogin)
|
|
launchAtLoginCheckbox.state = LaunchAtLogin.isEnabled ? .on : .off
|
|
|
|
autoUpdateCheckbox.target = self
|
|
autoUpdateCheckbox.action = #selector(toggleAutoUpdate)
|
|
autoUpdateCheckbox.state = UpdateChecker.automaticCheckEnabled ? .on : .off
|
|
|
|
hideStartupPickerCheckbox.target = self
|
|
hideStartupPickerCheckbox.action = #selector(toggleHideStartupPicker)
|
|
hideStartupPickerCheckbox.state = StartupBehavior.hidePicker ? .on : .off
|
|
|
|
checkNowButton.target = self
|
|
checkNowButton.action = #selector(checkNow)
|
|
checkNowButton.bezelStyle = .rounded
|
|
|
|
stack = NSStackView(views: [
|
|
launchAtLoginCheckbox, clickActionRow, tagStyleRow, hideStartupPickerCheckbox,
|
|
autoUpdateCheckbox, checkNowButton,
|
|
])
|
|
stack.orientation = .vertical
|
|
stack.alignment = .leading
|
|
stack.spacing = 14
|
|
stack.edgeInsets = NSEdgeInsets(top: 20, left: 20, bottom: 20, right: 20)
|
|
stack.translatesAutoresizingMaskIntoConstraints = false
|
|
view.addSubview(stack)
|
|
NSLayoutConstraint.activate([
|
|
stack.topAnchor.constraint(equalTo: view.topAnchor),
|
|
stack.leadingAnchor.constraint(equalTo: view.leadingAnchor),
|
|
stack.trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor),
|
|
stack.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
])
|
|
|
|
updatePreferredSize()
|
|
}
|
|
|
|
override func viewDidLayout() {
|
|
super.viewDidLayout()
|
|
updatePreferredSize()
|
|
}
|
|
|
|
// NOT `stack.fittingSize` for the width — that was measured observing
|
|
// it clip a checkbox's label by a consistent amount regardless of
|
|
// when it's read (loadView vs. viewDidLayout: same result), so this
|
|
// isn't a measure-too-early timing issue, it's `NSStackView.fittingSize`
|
|
// itself undercounting a checkbox's true rendered width. Asking each
|
|
// control directly for its own `intrinsicContentSize` instead — which
|
|
// is what AutoLayout itself uses to size an unconstrained control —
|
|
// sidesteps whatever the stack's own aggregation is getting wrong.
|
|
private func updatePreferredSize() {
|
|
// Same reasoning for the label+popup rows: summed from their two
|
|
// controls plus the row spacing rather than trusting the row's
|
|
// own fittingSize.
|
|
let rowWidths = [
|
|
tagStyleLabel.intrinsicContentSize.width
|
|
+ tagStylePopUp.intrinsicContentSize.width + tagStyleRow.spacing,
|
|
clickActionLabel.intrinsicContentSize.width
|
|
+ clickActionPopUp.intrinsicContentSize.width + clickActionRow.spacing,
|
|
]
|
|
let widest = ([launchAtLoginCheckbox, hideStartupPickerCheckbox, autoUpdateCheckbox, checkNowButton]
|
|
.map(\.intrinsicContentSize.width) + rowWidths)
|
|
.max() ?? 0
|
|
preferredContentSize = NSSize(width: widest + 40, height: stack.fittingSize.height)
|
|
}
|
|
|
|
@objc private func changeTagStyle() {
|
|
let index = tagStylePopUp.indexOfSelectedItem
|
|
guard Self.tagStyles.indices.contains(index) else { return }
|
|
WindowOverlayPosition.style = Self.tagStyles[index].style
|
|
onOverlayStyleChanged?()
|
|
}
|
|
|
|
// Nothing to notify: the menu bar rebuilds its menu on every open and
|
|
// reads the setting then.
|
|
@objc private func changeClickAction() {
|
|
let index = clickActionPopUp.indexOfSelectedItem
|
|
guard Self.clickActions.indices.contains(index) else { return }
|
|
MenuClickBehavior.plainClick = Self.clickActions[index].action
|
|
}
|
|
|
|
@objc private func toggleLaunchAtLogin() {
|
|
do {
|
|
if launchAtLoginCheckbox.state == .on {
|
|
try LaunchAtLogin.enable()
|
|
} else {
|
|
try LaunchAtLogin.disable()
|
|
}
|
|
} catch {
|
|
launchAtLoginCheckbox.state = LaunchAtLogin.isEnabled ? .on : .off
|
|
NSAlert(error: error).runModal()
|
|
}
|
|
}
|
|
|
|
@objc private func toggleAutoUpdate() {
|
|
UpdateChecker.automaticCheckEnabled = autoUpdateCheckbox.state == .on
|
|
}
|
|
|
|
@objc private func toggleHideStartupPicker() {
|
|
StartupBehavior.hidePicker = hideStartupPickerCheckbox.state == .on
|
|
}
|
|
|
|
@objc private func checkNow() {
|
|
UpdateChecker.checkManually { result in
|
|
DispatchQueue.main.async {
|
|
let alert = NSAlert()
|
|
switch result {
|
|
case .upToDate:
|
|
alert.messageText = "You're up to date."
|
|
alert.runModal()
|
|
case .updateAvailable(let version, let url):
|
|
alert.messageText = "shannoncoat \(version) is available"
|
|
alert.addButton(withTitle: "View Release")
|
|
alert.addButton(withTitle: "Later")
|
|
if alert.runModal() == .alertFirstButtonReturn {
|
|
NSWorkspace.shared.open(url)
|
|
}
|
|
case .failed:
|
|
alert.alertStyle = .warning
|
|
alert.messageText = "Couldn't check for updates."
|
|
alert.runModal()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - About tab
|
|
|
|
private let projectHomepage = "https://github.com/bdeshi/shannoncoat"
|
|
|
|
private final class AboutViewController: NSViewController {
|
|
private static let contentWidth: CGFloat = 340
|
|
|
|
override func loadView() {
|
|
view = NSView(frame: NSRect(x: 0, y: 0, width: 420, height: 150))
|
|
|
|
// Centered within a full-width wrapper rather than centered in the
|
|
// stack directly — the stack is leading-aligned (for the text
|
|
// rows below), and its own per-arranged-subview alignment
|
|
// constraint on the icon would conflict with an added centering
|
|
// constraint on the icon itself.
|
|
let icon = NSImageView()
|
|
icon.image = NSApp.applicationIconImage ?? NSImage(named: NSImage.applicationIconName)
|
|
icon.translatesAutoresizingMaskIntoConstraints = false
|
|
let iconContainer = NSView()
|
|
iconContainer.translatesAutoresizingMaskIntoConstraints = false
|
|
iconContainer.addSubview(icon)
|
|
NSLayoutConstraint.activate([
|
|
icon.widthAnchor.constraint(equalToConstant: 96),
|
|
icon.heightAnchor.constraint(equalToConstant: 96),
|
|
icon.topAnchor.constraint(equalTo: iconContainer.topAnchor),
|
|
icon.bottomAnchor.constraint(equalTo: iconContainer.bottomAnchor),
|
|
icon.centerXAnchor.constraint(equalTo: iconContainer.centerXAnchor),
|
|
])
|
|
|
|
// Centred under the icon, same wrapper trick as the icon itself.
|
|
let tagline = NSTextField(labelWithString: "which coat will Claude wear today?")
|
|
tagline.font = .systemFont(ofSize: NSFont.systemFontSize)
|
|
tagline.textColor = .secondaryLabelColor
|
|
tagline.translatesAutoresizingMaskIntoConstraints = false
|
|
let taglineContainer = NSView()
|
|
taglineContainer.translatesAutoresizingMaskIntoConstraints = false
|
|
taglineContainer.addSubview(tagline)
|
|
NSLayoutConstraint.activate([
|
|
tagline.topAnchor.constraint(equalTo: taglineContainer.topAnchor),
|
|
tagline.bottomAnchor.constraint(equalTo: taglineContainer.bottomAnchor),
|
|
tagline.centerXAnchor.constraint(equalTo: taglineContainer.centerXAnchor),
|
|
])
|
|
|
|
// Names itself rather than opening with a bare verb — this panel is
|
|
// reachable without the window title in view.
|
|
let description = NSTextField(wrappingLabelWithString:
|
|
"shannoncoat runs multiple Claude Desktop profiles side by side, each paired with its own "
|
|
+ "isolated Claude Code config.")
|
|
description.font = .systemFont(ofSize: NSFont.systemFontSize)
|
|
|
|
let sourceField = NSTextField(labelWithString: "Source: \(projectHomepage)")
|
|
let versionField = NSTextField(labelWithString: "Version: \(UpdateChecker.displayVersion)")
|
|
for field in [sourceField, versionField] {
|
|
field.textColor = .secondaryLabelColor
|
|
field.font = .systemFont(ofSize: NSFont.smallSystemFontSize)
|
|
}
|
|
|
|
let stack = NSStackView(views: [iconContainer, taglineContainer, description,
|
|
sourceField, versionField])
|
|
stack.orientation = .vertical
|
|
stack.alignment = .leading
|
|
stack.spacing = 10
|
|
stack.edgeInsets = NSEdgeInsets(top: 20, left: 20, bottom: 20, right: 20)
|
|
stack.translatesAutoresizingMaskIntoConstraints = false
|
|
view.addSubview(stack)
|
|
|
|
NSLayoutConstraint.activate([
|
|
stack.topAnchor.constraint(equalTo: view.topAnchor),
|
|
stack.leadingAnchor.constraint(equalTo: view.leadingAnchor),
|
|
stack.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
description.widthAnchor.constraint(equalToConstant: Self.contentWidth),
|
|
iconContainer.widthAnchor.constraint(equalTo: description.widthAnchor),
|
|
taglineContainer.widthAnchor.constraint(equalTo: description.widthAnchor),
|
|
])
|
|
|
|
view.layoutSubtreeIfNeeded()
|
|
preferredContentSize = NSSize(width: Self.contentWidth + 40, height: stack.fittingSize.height)
|
|
}
|
|
}
|